1
          
          require File.expand_path('../boot', __FILE__)
        
      
        

          
          
          
        
      
        

          1
          
          require 'rails/all'
        
      
        

          
          
          
        
      
        

          1
          
          if defined?(Bundler)
        
      
        

          
          
            # If you precompile assets before deploying to production, use this line
        
      
        

          1
          
            Bundler.require *Rails.groups(:assets => %w(development test))
        
      
        

          
          
            # If you want your assets lazily compiled in production, use this line
        
      
        

          
          
            # Bundler.require(:default, :assets, Rails.env)
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          module ICA
        
      
        

          
          
            class Application < Rails::Application
        
      
        

          
          
              # Settings in config/environments/* take precedence over those specified here.
        
      
        

          
          
              # Application configuration should go into files in config/initializers
        
      
        

          
          
              # -- all .rb files in that directory are automatically loaded.
        
      
        

          
          
          
        
      
        

          
          
              # Custom directories with classes and modules you want to be autoloadable.
        
      
        

          
          
              # config.autoload_paths += %W(#{config.root}/extras)
        
      
        

          
          
          
        
      
        

          
          
              # Only load the plugins named here, in the order given (default is alphabetical).
        
      
        

          
          
              # :all can be used as a placeholder for all plugins not explicitly named.
        
      
        

          
          
              # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
        
      
        

          
          
          
        
      
        

          
          
              # Activate observers that should always be running.
        
      
        

          
          
              # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
        
      
        

          
          
          
        
      
        

          
          
              # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
        
      
        

          
          
              # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
        
      
        

          
          
              # config.time_zone = 'Central Time (US & Canada)'
        
      
        

          
          
          
        
      
        

          
          
              # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
        
      
        

          
          
              # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
        
      
        

          
          
              # config.i18n.default_locale = :de
        
      
        

          
          
          
        
      
        

          
          
              # Configure the default encoding used in templates for Ruby 1.9.
        
      
        

          
          
              config.encoding = "utf-8"
        
      
        

          
          
          
        
      
        

          
          
              # Configure sensitive parameters which will be filtered from the log file.
        
      
        

          
          
              config.filter_parameters += [:password]
        
      
        

          
          
          
        
      
        

          
          
              # Enable the asset pipeline
        
      
        

          
          
              config.assets.enabled = true
        
      
        

          
          
          
        
      
        

          
          
              # Version of your assets, change this if you want to expire all your assets
        
      
        

          
          
              config.assets.version = '1.0'
        
      
        

          
          
          
        
      
        

          
          
              # Remove field_with_error div wrapping invalid classes since it messes with Bootstrap styling
        
      
        

          
          
              config.action_view.field_error_proc = Proc.new { |html_tag, instance| "#{html_tag}".html_safe }
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'rubygems'
        
      
        

          
          
          
        
      
        

          
          
          # Set up gems listed in the Gemfile.
        
      
        

          1
          
          ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
        
      
        

          
          
          
        
      
        

          1
          
          require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
        
      
    
  

    

      
        

          
          
          # Load the rails application
        
      
        

          1
          
          require File.expand_path('../application', __FILE__)
        
      
        

          
          
          
        
      
        

          
          
          # Initialize the rails application
        
      
        

          
          
          ICA::Application.initialize!
        
      
    
  

    

      
        

          
          
          #--
        
      
        

          
          
          # Copyright (c) 2004-2011 David Heinemeier Hansson
        
      
        

          
          
          #
        
      
        

          
          
          # Permission is hereby granted, free of charge, to any person obtaining
        
      
        

          
          
          # a copy of this software and associated documentation files (the
        
      
        

          
          
          # "Software"), to deal in the Software without restriction, including
        
      
        

          
          
          # without limitation the rights to use, copy, modify, merge, publish,
        
      
        

          
          
          # distribute, sublicense, and/or sell copies of the Software, and to
        
      
        

          
          
          # permit persons to whom the Software is furnished to do so, subject to
        
      
        

          
          
          # the following conditions:
        
      
        

          
          
          #
        
      
        

          
          
          # The above copyright notice and this permission notice shall be
        
      
        

          
          
          # included in all copies or substantial portions of the Software.
        
      
        

          
          
          #
        
      
        

          
          
          # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
        
      
        

          
          
          # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        
      
        

          
          
          # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
        
      
        

          
          
          # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
        
      
        

          
          
          # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
        
      
        

          
          
          # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
        
      
        

          
          
          # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
        
      
        

          
          
          #++
        
      
        

          
          
          
        
      
        

          1
          
          actionpack_path = File.expand_path('../../../actionpack/lib', __FILE__)
        
      
        

          1
          
          $:.unshift(actionpack_path) if File.directory?(actionpack_path) && !$:.include?(actionpack_path)
        
      
        

          
          
          
        
      
        

          1
          
          require 'abstract_controller'
        
      
        

          1
          
          require 'action_view'
        
      
        

          1
          
          require 'action_mailer/version'
        
      
        

          
          
          
        
      
        

          
          
          # Common Active Support usage in Action Mailer
        
      
        

          1
          
          require 'active_support/core_ext/class'
        
      
        

          1
          
          require 'active_support/core_ext/object/blank'
        
      
        

          1
          
          require 'active_support/core_ext/array/uniq_by'
        
      
        

          1
          
          require 'active_support/core_ext/module/attr_internal'
        
      
        

          1
          
          require 'active_support/core_ext/module/delegation'
        
      
        

          1
          
          require 'active_support/core_ext/string/inflections'
        
      
        

          1
          
          require 'active_support/lazy_load_hooks'
        
      
        

          
          
          
        
      
        

          1
          
          module ActionMailer
        
      
        

          1
          
            extend ::ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
            autoload :AdvAttrAccessor
        
      
        

          1
          
            autoload :Collector
        
      
        

          1
          
            autoload :Base
        
      
        

          1
          
            autoload :DeliveryMethods
        
      
        

          1
          
            autoload :MailHelper
        
      
        

          1
          
            autoload :OldApi
        
      
        

          1
          
            autoload :TestCase
        
      
        

          1
          
            autoload :TestHelper
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require "action_mailer"
        
      
        

          1
          
          require "rails"
        
      
        

          1
          
          require "abstract_controller/railties/routes_helpers"
        
      
        

          
          
          
        
      
        

          1
          
          module ActionMailer
        
      
        

          1
          
            class Railtie < Rails::Railtie
        
      
        

          1
          
              config.action_mailer = ActiveSupport::OrderedOptions.new
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_mailer.logger" do
        
      
        

          
          
                ActiveSupport.on_load(:action_mailer) { self.logger ||= Rails.logger }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_mailer.set_configs" do |app|
        
      
        

          
          
                paths   = app.config.paths
        
      
        

          
          
                options = app.config.action_mailer
        
      
        

          
          
          
        
      
        

          
          
                options.assets_dir      ||= paths["public"].first
        
      
        

          
          
                options.javascripts_dir ||= paths["public/javascripts"].first
        
      
        

          
          
                options.stylesheets_dir ||= paths["public/stylesheets"].first
        
      
        

          
          
          
        
      
        

          
          
                # make sure readers methods get compiled
        
      
        

          
          
                options.asset_path      ||= app.config.asset_path
        
      
        

          
          
                options.asset_host      ||= app.config.asset_host
        
      
        

          
          
          
        
      
        

          
          
                ActiveSupport.on_load(:action_mailer) do
        
      
        

          
          
                  include AbstractController::UrlFor
        
      
        

          
          
                  extend ::AbstractController::Railties::RoutesHelpers.with(app.routes)
        
      
        

          
          
                  include app.routes.mounted_helpers
        
      
        

          
          
          
        
      
        

          
          
                  register_interceptors(options.delete(:interceptors))
        
      
        

          
          
                  register_observers(options.delete(:observers))
        
      
        

          
          
          
        
      
        

          
          
                  options.each { |k,v| send("#{k}=", v) }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_mailer.compile_config_methods" do
        
      
        

          
          
                ActiveSupport.on_load(:action_mailer) do
        
      
        

          
          
                  config.compile_methods! if config.respond_to?(:compile_methods!)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module ActionMailer
        
      
        

          1
          
            module VERSION #:nodoc:
        
      
        

          1
          
              MAJOR = 3
        
      
        

          1
          
              MINOR = 1
        
      
        

          1
          
              TINY  = 0
        
      
        

          1
          
              PRE   = nil
        
      
        

          
          
          
        
      
        

          1
          
              STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
        
      
        

          1
          
          $:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
        
      
        

          
          
          
        
      
        

          1
          
          require 'action_pack'
        
      
        

          1
          
          require 'active_support/concern'
        
      
        

          1
          
          require 'active_support/ruby/shim'
        
      
        

          1
          
          require 'active_support/dependencies/autoload'
        
      
        

          1
          
          require 'active_support/core_ext/class/attribute'
        
      
        

          1
          
          require 'active_support/core_ext/module/attr_internal'
        
      
        

          1
          
          require 'active_support/core_ext/module/delegation'
        
      
        

          1
          
          require 'active_support/core_ext/module/anonymous'
        
      
        

          1
          
          require 'active_support/i18n'
        
      
        

          
          
          
        
      
        

          1
          
          module AbstractController
        
      
        

          1
          
            extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
            autoload :Base
        
      
        

          1
          
            autoload :Callbacks
        
      
        

          1
          
            autoload :Collector
        
      
        

          1
          
            autoload :Helpers
        
      
        

          1
          
            autoload :Layouts
        
      
        

          1
          
            autoload :Logger
        
      
        

          1
          
            autoload :Rendering
        
      
        

          1
          
            autoload :Translation
        
      
        

          1
          
            autoload :AssetPaths
        
      
        

          1
          
            autoload :ViewPaths
        
      
        

          1
          
            autoload :UrlFor
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module AbstractController
        
      
        

          1
          
            module Railties
        
      
        

          1
          
              module RoutesHelpers
        
      
        

          1
          
                def self.with(routes)
        
      
        

          
          
                  Module.new do
        
      
        

          
          
                    define_method(:inherited) do |klass|
        
      
        

          
          
                      super(klass)
        
      
        

          
          
                      if namespace = klass.parents.detect {|m| m.respond_to?(:_railtie) }
        
      
        

          
          
                        klass.send(:include, namespace._railtie.routes.url_helpers)
        
      
        

          
          
                      else
        
      
        

          
          
                        klass.send(:include, routes.url_helpers)
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'abstract_controller'
        
      
        

          1
          
          require 'action_dispatch'
        
      
        

          
          
          
        
      
        

          1
          
          module ActionController
        
      
        

          1
          
            extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
            autoload :Base
        
      
        

          1
          
            autoload :Caching
        
      
        

          1
          
            autoload :Metal
        
      
        

          1
          
            autoload :Middleware
        
      
        

          
          
          
        
      
        

          1
          
            autoload_under "metal" do
        
      
        

          1
          
              autoload :Compatibility
        
      
        

          1
          
              autoload :ConditionalGet
        
      
        

          1
          
              autoload :Cookies
        
      
        

          1
          
              autoload :DataStreaming
        
      
        

          1
          
              autoload :Flash
        
      
        

          1
          
              autoload :ForceSSL
        
      
        

          1
          
              autoload :Head
        
      
        

          1
          
              autoload :Helpers
        
      
        

          1
          
              autoload :HideActions
        
      
        

          1
          
              autoload :HttpAuthentication
        
      
        

          1
          
              autoload :ImplicitRender
        
      
        

          1
          
              autoload :Instrumentation
        
      
        

          1
          
              autoload :MimeResponds
        
      
        

          1
          
              autoload :ParamsWrapper
        
      
        

          1
          
              autoload :RackDelegation
        
      
        

          1
          
              autoload :Redirecting
        
      
        

          1
          
              autoload :Renderers
        
      
        

          1
          
              autoload :Rendering
        
      
        

          1
          
              autoload :RequestForgeryProtection
        
      
        

          1
          
              autoload :Rescue
        
      
        

          1
          
              autoload :Responder
        
      
        

          1
          
              autoload :SessionManagement
        
      
        

          1
          
              autoload :Streaming
        
      
        

          1
          
              autoload :Testing
        
      
        

          1
          
              autoload :UrlFor
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            autoload :Integration,        'action_controller/deprecated/integration_test'
        
      
        

          1
          
            autoload :IntegrationTest,    'action_controller/deprecated/integration_test'
        
      
        

          1
          
            autoload :PerformanceTest,    'action_controller/deprecated/performance_test'
        
      
        

          1
          
            autoload :UrlWriter,          'action_controller/deprecated'
        
      
        

          1
          
            autoload :Routing,            'action_controller/deprecated'
        
      
        

          1
          
            autoload :TestCase,           'action_controller/test_case'
        
      
        

          1
          
            autoload :TemplateAssertions, 'action_controller/test_case'
        
      
        

          
          
          
        
      
        

          1
          
            eager_autoload do
        
      
        

          1
          
              autoload :RecordIdentifier
        
      
        

          
          
          
        
      
        

          
          
              # TODO: Don't autoload exceptions, setup explicit
        
      
        

          
          
              # requires for files that need them
        
      
        

          1
          
              autoload_at "action_controller/metal/exceptions" do
        
      
        

          1
          
                autoload :ActionControllerError
        
      
        

          1
          
                autoload :RenderError
        
      
        

          1
          
                autoload :RoutingError
        
      
        

          1
          
                autoload :MethodNotAllowed
        
      
        

          1
          
                autoload :NotImplemented
        
      
        

          1
          
                autoload :UnknownController
        
      
        

          1
          
                autoload :MissingFile
        
      
        

          1
          
                autoload :RenderError
        
      
        

          1
          
                autoload :SessionOverflowError
        
      
        

          1
          
                autoload :UnknownHttpMethod
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          # All of these simply register additional autoloads
        
      
        

          1
          
          require 'action_view'
        
      
        

          1
          
          require 'action_controller/vendor/html-scanner'
        
      
        

          
          
          
        
      
        

          
          
          # Common Active Support usage in Action Controller
        
      
        

          1
          
          require 'active_support/concern'
        
      
        

          1
          
          require 'active_support/core_ext/class/attribute_accessors'
        
      
        

          1
          
          require 'active_support/core_ext/load_error'
        
      
        

          1
          
          require 'active_support/core_ext/module/attr_internal'
        
      
        

          1
          
          require 'active_support/core_ext/module/delegation'
        
      
        

          1
          
          require 'active_support/core_ext/name_error'
        
      
        

          1
          
          require 'active_support/core_ext/uri'
        
      
        

          1
          
          require 'active_support/inflector'
        
      
    
  

    

      
        

          1
          
          require "rails"
        
      
        

          1
          
          require "action_controller"
        
      
        

          1
          
          require "action_dispatch/railtie"
        
      
        

          1
          
          require "action_view/railtie"
        
      
        

          1
          
          require "abstract_controller/railties/routes_helpers"
        
      
        

          1
          
          require "action_controller/railties/paths"
        
      
        

          
          
          
        
      
        

          1
          
          module ActionController
        
      
        

          1
          
            class Railtie < Rails::Railtie
        
      
        

          1
          
              config.action_controller = ActiveSupport::OrderedOptions.new
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_controller.logger" do
        
      
        

          
          
                ActiveSupport.on_load(:action_controller) { self.logger ||= Rails.logger }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_controller.initialize_framework_caches" do
        
      
        

          
          
                ActiveSupport.on_load(:action_controller) { self.cache_store ||= RAILS_CACHE }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_controller.set_configs" do |app|
        
      
        

          
          
                paths   = app.config.paths
        
      
        

          
          
                options = app.config.action_controller
        
      
        

          
          
          
        
      
        

          
          
                options.assets_dir           ||= paths["public"].first
        
      
        

          
          
                options.javascripts_dir      ||= paths["public/javascripts"].first
        
      
        

          
          
                options.stylesheets_dir      ||= paths["public/stylesheets"].first
        
      
        

          
          
                options.page_cache_directory ||= paths["public"].first
        
      
        

          
          
          
        
      
        

          
          
                # make sure readers methods get compiled
        
      
        

          
          
                options.asset_path           ||= app.config.asset_path
        
      
        

          
          
                options.asset_host           ||= app.config.asset_host
        
      
        

          
          
          
        
      
        

          
          
                ActiveSupport.on_load(:action_controller) do
        
      
        

          
          
                  include app.routes.mounted_helpers
        
      
        

          
          
                  extend ::AbstractController::Railties::RoutesHelpers.with(app.routes)
        
      
        

          
          
                  extend ::ActionController::Railties::Paths.with(app)
        
      
        

          
          
                  options.each { |k,v| send("#{k}=", v) }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_controller.compile_config_methods" do
        
      
        

          
          
                ActiveSupport.on_load(:action_controller) do
        
      
        

          
          
                  config.compile_methods! if config.respond_to?(:compile_methods!)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module ActionController
        
      
        

          1
          
            module Railties
        
      
        

          1
          
              module Paths
        
      
        

          1
          
                def self.with(app)
        
      
        

          
          
                  Module.new do
        
      
        

          
          
                    define_method(:inherited) do |klass|
        
      
        

          
          
                      super(klass)
        
      
        

          
          
          
        
      
        

          
          
                      if namespace = klass.parents.detect {|m| m.respond_to?(:_railtie) }
        
      
        

          
          
                        paths = namespace._railtie.paths["app/helpers"].existent
        
      
        

          
          
                      else
        
      
        

          
          
                        paths = app.config.helpers_paths
        
      
        

          
          
                      end
        
      
        

          
          
          
        
      
        

          
          
                      klass.helpers_path = paths
        
      
        

          
          
                      if klass.superclass == ActionController::Base && ActionController::Base.include_all_helpers
        
      
        

          
          
                        klass.helper :all
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          $LOAD_PATH << "#{File.dirname(__FILE__)}/html-scanner"
        
      
        

          
          
          
        
      
        

          1
          
          module HTML
        
      
        

          1
          
            extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
            eager_autoload do
        
      
        

          1
          
              autoload :CDATA, 'html/node'
        
      
        

          1
          
              autoload :Document, 'html/document'
        
      
        

          1
          
              autoload :FullSanitizer, 'html/sanitizer'
        
      
        

          1
          
              autoload :LinkSanitizer, 'html/sanitizer'
        
      
        

          1
          
              autoload :Node, 'html/node'
        
      
        

          1
          
              autoload :Sanitizer, 'html/sanitizer'
        
      
        

          1
          
              autoload :Selector, 'html/selector'
        
      
        

          1
          
              autoload :Tag, 'html/node'
        
      
        

          1
          
              autoload :Text, 'html/node'
        
      
        

          1
          
              autoload :Tokenizer, 'html/tokenizer'
        
      
        

          1
          
              autoload :Version, 'html/version'
        
      
        

          1
          
              autoload :WhiteListSanitizer, 'html/sanitizer'
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #--
        
      
        

          
          
          # Copyright (c) 2004-2011 David Heinemeier Hansson
        
      
        

          
          
          #
        
      
        

          
          
          # Permission is hereby granted, free of charge, to any person obtaining
        
      
        

          
          
          # a copy of this software and associated documentation files (the
        
      
        

          
          
          # "Software"), to deal in the Software without restriction, including
        
      
        

          
          
          # without limitation the rights to use, copy, modify, merge, publish,
        
      
        

          
          
          # distribute, sublicense, and/or sell copies of the Software, and to
        
      
        

          
          
          # permit persons to whom the Software is furnished to do so, subject to
        
      
        

          
          
          # the following conditions:
        
      
        

          
          
          #
        
      
        

          
          
          # The above copyright notice and this permission notice shall be
        
      
        

          
          
          # included in all copies or substantial portions of the Software.
        
      
        

          
          
          #
        
      
        

          
          
          # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
        
      
        

          
          
          # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        
      
        

          
          
          # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
        
      
        

          
          
          # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
        
      
        

          
          
          # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
        
      
        

          
          
          # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
        
      
        

          
          
          # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
        
      
        

          
          
          #++
        
      
        

          
          
          
        
      
        

          1
          
          require 'active_support/ruby/shim'
        
      
        

          1
          
          require 'active_support/core_ext/class/attribute_accessors'
        
      
        

          
          
          
        
      
        

          1
          
          require 'action_pack'
        
      
        

          
          
          
        
      
        

          1
          
          module ActionView
        
      
        

          1
          
            extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
            eager_autoload do
        
      
        

          1
          
              autoload :AssetPaths
        
      
        

          1
          
              autoload :Base
        
      
        

          1
          
              autoload :Context
        
      
        

          1
          
              autoload :Helpers
        
      
        

          1
          
              autoload :LookupContext
        
      
        

          1
          
              autoload :PathSet
        
      
        

          1
          
              autoload :Template
        
      
        

          1
          
              autoload :TestCase
        
      
        

          
          
          
        
      
        

          1
          
              autoload_under "renderer" do
        
      
        

          1
          
                autoload :Renderer
        
      
        

          1
          
                autoload :AbstractRenderer
        
      
        

          1
          
                autoload :PartialRenderer
        
      
        

          1
          
                autoload :TemplateRenderer
        
      
        

          1
          
                autoload :StreamingTemplateRenderer
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              autoload_at "action_view/template/resolver" do
        
      
        

          1
          
                autoload :Resolver
        
      
        

          1
          
                autoload :PathResolver
        
      
        

          1
          
                autoload :FileSystemResolver
        
      
        

          1
          
                autoload :OptimizedFileSystemResolver
        
      
        

          1
          
                autoload :FallbackFileSystemResolver
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              autoload_at "action_view/buffers" do
        
      
        

          1
          
                autoload :OutputBuffer
        
      
        

          1
          
                autoload :StreamingBuffer
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              autoload_at "action_view/flows" do
        
      
        

          1
          
                autoload :OutputFlow
        
      
        

          1
          
                autoload :StreamingFlow
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              autoload_at "action_view/template/error" do
        
      
        

          1
          
                autoload :MissingTemplate
        
      
        

          1
          
                autoload :ActionViewError
        
      
        

          1
          
                autoload :EncodingError
        
      
        

          1
          
                autoload :TemplateError
        
      
        

          1
          
                autoload :WrongEncodingError
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              autoload_at "action_view/template" do
        
      
        

          1
          
                autoload :TemplateHandler
        
      
        

          1
          
                autoload :TemplateHandlers
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            ENCODING_FLAG = '#.*coding[:=]\s*(\S+)[ \t]*'
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          require 'active_support/i18n'
        
      
        

          1
          
          require 'active_support/core_ext/string/output_safety'
        
      
        

          
          
          
        
      
        

          1
          
          I18n.load_path << "#{File.dirname(__FILE__)}/action_view/locale/en.yml"
        
      
    
  

    

      
        

          1
          
          require "action_view"
        
      
        

          1
          
          require "rails"
        
      
        

          
          
          
        
      
        

          1
          
          module ActionView
        
      
        

          
          
            # = Action View Railtie
        
      
        

          1
          
            class Railtie < Rails::Railtie
        
      
        

          1
          
              config.action_view = ActiveSupport::OrderedOptions.new
        
      
        

          1
          
              config.action_view.stylesheet_expansions = {}
        
      
        

          1
          
              config.action_view.javascript_expansions = { :defaults => %w(jquery jquery_ujs) }
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_view.cache_asset_ids" do |app|
        
      
        

          
          
                unless app.config.cache_classes
        
      
        

          
          
                  ActiveSupport.on_load(:action_view) do
        
      
        

          
          
                    ActionView::Helpers::AssetTagHelper::AssetPaths.cache_asset_ids = false
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_view.javascript_expansions" do |app|
        
      
        

          
          
                ActiveSupport.on_load(:action_view) do
        
      
        

          
          
                  ActionView::Helpers::AssetTagHelper.register_javascript_expansion(
        
      
        

          
          
                    app.config.action_view.delete(:javascript_expansions)
        
      
        

          
          
                  )
        
      
        

          
          
          
        
      
        

          
          
                  ActionView::Helpers::AssetTagHelper.register_stylesheet_expansion(
        
      
        

          
          
                    app.config.action_view.delete(:stylesheet_expansions)
        
      
        

          
          
                  )
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_view.set_configs" do |app|
        
      
        

          
          
                ActiveSupport.on_load(:action_view) do
        
      
        

          
          
                  app.config.action_view.each do |k,v|
        
      
        

          
          
                    send "#{k}=", v
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "action_view.caching" do |app|
        
      
        

          
          
                ActiveSupport.on_load(:action_view) do
        
      
        

          
          
                  if app.config.action_view.cache_template_loading.nil?
        
      
        

          
          
                    ActionView::Resolver.caching = app.config.cache_classes
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module Sprockets
        
      
        

          1
          
            autoload :Helpers, "sprockets/helpers"
        
      
        

          1
          
            autoload :LazyCompressor, "sprockets/compressors"
        
      
        

          1
          
            autoload :NullCompressor, "sprockets/compressors"
        
      
        

          
          
          
        
      
        

          
          
            # TODO: Get rid of config.assets.enabled
        
      
        

          1
          
            class Railtie < ::Rails::Railtie
        
      
        

          1
          
              config.default_asset_host_protocol = :relative
        
      
        

          
          
          
        
      
        

          1
          
              rake_tasks do
        
      
        

          
          
                load "sprockets/assets.rake"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "sprockets.environment" do |app|
        
      
        

          
          
                config = app.config
        
      
        

          
          
                next unless config.assets.enabled
        
      
        

          
          
          
        
      
        

          
          
                require 'sprockets'
        
      
        

          
          
          
        
      
        

          
          
                app.assets = Sprockets::Environment.new(app.root.to_s) do |env|
        
      
        

          
          
                  env.logger  = ::Rails.logger
        
      
        

          
          
                  env.version = ::Rails.env + "-#{config.assets.version}"
        
      
        

          
          
          
        
      
        

          
          
                  if config.assets.cache_store != false
        
      
        

          
          
                    env.cache = ActiveSupport::Cache.lookup_store(config.assets.cache_store) || ::Rails.cache
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                if config.assets.manifest
        
      
        

          
          
                  path = File.join(config.assets.manifest, "manifest.yml")
        
      
        

          
          
                else
        
      
        

          
          
                  path = File.join(Rails.public_path, config.assets.prefix, "manifest.yml")
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                if File.exist?(path)
        
      
        

          
          
                  config.assets.digests = YAML.load_file(path)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                ActiveSupport.on_load(:action_view) do
        
      
        

          
          
                  include ::Sprockets::Helpers::RailsHelper
        
      
        

          
          
          
        
      
        

          
          
                  app.assets.context_class.instance_eval do
        
      
        

          
          
                    include ::Sprockets::Helpers::RailsHelper
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # We need to configure this after initialization to ensure we collect
        
      
        

          
          
              # paths from all engines. This hook is invoked exactly before routes
        
      
        

          
          
              # are compiled, and so that other Railties have an opportunity to
        
      
        

          
          
              # register compressors.
        
      
        

          1
          
              config.after_initialize do |app|
        
      
        

          
          
                next unless app.assets
        
      
        

          
          
                config = app.config
        
      
        

          
          
          
        
      
        

          
          
                config.assets.paths.each { |path| app.assets.append_path(path) }
        
      
        

          
          
          
        
      
        

          
          
                if config.assets.compress
        
      
        

          
          
                  # temporarily hardcode default JS compressor to uglify. Soon, it will work
        
      
        

          
          
                  # the same as SCSS, where a default plugin sets the default.
        
      
        

          
          
                  unless config.assets.js_compressor == false
        
      
        

          
          
                    app.assets.js_compressor = LazyCompressor.new { expand_js_compressor(config.assets.js_compressor || :uglifier) }
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          
          
                  unless config.assets.css_compressor == false
        
      
        

          
          
                    app.assets.css_compressor = LazyCompressor.new { expand_css_compressor(config.assets.css_compressor) }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                app.routes.prepend do
        
      
        

          
          
                  mount app.assets => config.assets.prefix
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                if config.action_controller.perform_caching
        
      
        

          
          
                  app.assets = app.assets.index
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              protected
        
      
        

          1
          
                def expand_js_compressor(sym)
        
      
        

          
          
                  case sym
        
      
        

          
          
                  when :closure
        
      
        

          
          
                    require 'closure-compiler'
        
      
        

          
          
                    Closure::Compiler.new
        
      
        

          
          
                  when :uglifier
        
      
        

          
          
                    require 'uglifier'
        
      
        

          
          
                    Uglifier.new
        
      
        

          
          
                  when :yui
        
      
        

          
          
                    require 'yui/compressor'
        
      
        

          
          
                    YUI::JavaScriptCompressor.new
        
      
        

          
          
                  else
        
      
        

          
          
                    sym
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def expand_css_compressor(sym)
        
      
        

          
          
                  case sym
        
      
        

          
          
                  when :yui
        
      
        

          
          
                    require 'yui/compressor'
        
      
        

          
          
                    YUI::CssCompressor.new
        
      
        

          
          
                  else
        
      
        

          
          
                    sym
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'active_support/core_ext/hash/keys'
        
      
        

          1
          
          require 'active_support/core_ext/class/attribute'
        
      
        

          
          
          
        
      
        

          1
          
          module ActiveModel
        
      
        

          1
          
            class MissingAttributeError < NoMethodError
        
      
        

          
          
            end
        
      
        

          
          
            # == Active Model Attribute Methods
        
      
        

          
          
            #
        
      
        

          
          
            # <tt>ActiveModel::AttributeMethods</tt> provides a way to add prefixes and suffixes
        
      
        

          
          
            # to your methods as well as handling the creation of Active Record like class methods
        
      
        

          
          
            # such as +table_name+.
        
      
        

          
          
            #
        
      
        

          
          
            # The requirements to implement ActiveModel::AttributeMethods are to:
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>include ActiveModel::AttributeMethods</tt> in your object
        
      
        

          
          
            # * Call each Attribute Method module method you want to add, such as
        
      
        

          
          
            #   attribute_method_suffix or attribute_method_prefix
        
      
        

          
          
            # * Call <tt>define_attribute_methods</tt> after the other methods are
        
      
        

          
          
            #   called.
        
      
        

          
          
            # * Define the various generic +_attribute+ methods that you have declared
        
      
        

          
          
            #
        
      
        

          
          
            # A minimal implementation could be:
        
      
        

          
          
            #
        
      
        

          
          
            #   class Person
        
      
        

          
          
            #     include ActiveModel::AttributeMethods
        
      
        

          
          
            #
        
      
        

          
          
            #     attribute_method_affix  :prefix => 'reset_', :suffix => '_to_default!'
        
      
        

          
          
            #     attribute_method_suffix '_contrived?'
        
      
        

          
          
            #     attribute_method_prefix 'clear_'
        
      
        

          
          
            #     define_attribute_methods ['name']
        
      
        

          
          
            #
        
      
        

          
          
            #     attr_accessor :name
        
      
        

          
          
            #
        
      
        

          
          
            #     private
        
      
        

          
          
            #
        
      
        

          
          
            #     def attribute_contrived?(attr)
        
      
        

          
          
            #       true
        
      
        

          
          
            #     end
        
      
        

          
          
            #
        
      
        

          
          
            #     def clear_attribute(attr)
        
      
        

          
          
            #       send("#{attr}=", nil)
        
      
        

          
          
            #     end
        
      
        

          
          
            #
        
      
        

          
          
            #     def reset_attribute_to_default!(attr)
        
      
        

          
          
            #       send("#{attr}=", "Default Name")
        
      
        

          
          
            #     end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Note that whenever you include ActiveModel::AttributeMethods in your class,
        
      
        

          
          
            # it requires you to implement an <tt>attributes</tt> method which returns a hash
        
      
        

          
          
            # with each attribute name in your model as hash key and the attribute value as
        
      
        

          
          
            # hash value.
        
      
        

          
          
            #
        
      
        

          
          
            # Hash keys must be strings.
        
      
        

          
          
            #
        
      
        

          1
          
            module AttributeMethods
        
      
        

          1
          
              extend ActiveSupport::Concern
        
      
        

          
          
          
        
      
        

          1
          
              COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
        
      
        

          
          
          
        
      
        

          1
          
              included do
        
      
        

          
          
                class_attribute :attribute_method_matchers, :instance_writer => false
        
      
        

          
          
                self.attribute_method_matchers = []
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              module ClassMethods
        
      
        

          
          
                # Defines an "attribute" method (like +inheritance_column+ or +table_name+).
        
      
        

          
          
                # A new (class) method will be created with the given name. If a value is
        
      
        

          
          
                # specified, the new method will return that value (as a string).
        
      
        

          
          
                # Otherwise, the given block will be used to compute the value of the
        
      
        

          
          
                # method.
        
      
        

          
          
                #
        
      
        

          
          
                # The original method will be aliased, with the new name being prefixed
        
      
        

          
          
                # with "original_". This allows the new method to access the original
        
      
        

          
          
                # value.
        
      
        

          
          
                #
        
      
        

          
          
                # Example:
        
      
        

          
          
                #
        
      
        

          
          
                #   class Person
        
      
        

          
          
                #
        
      
        

          
          
                #     include ActiveModel::AttributeMethods
        
      
        

          
          
                #
        
      
        

          
          
                #     cattr_accessor :primary_key
        
      
        

          
          
                #     cattr_accessor :inheritance_column
        
      
        

          
          
                #
        
      
        

          
          
                #     define_attr_method :primary_key, "sysid"
        
      
        

          
          
                #     define_attr_method( :inheritance_column ) do
        
      
        

          
          
                #       original_inheritance_column + "_id"
        
      
        

          
          
                #     end
        
      
        

          
          
                #
        
      
        

          
          
                #   end
        
      
        

          
          
                #
        
      
        

          
          
                # Provides you with:
        
      
        

          
          
                #
        
      
        

          
          
                #   AttributePerson.primary_key
        
      
        

          
          
                #   # => "sysid"
        
      
        

          
          
                #   AttributePerson.inheritance_column = 'address'
        
      
        

          
          
                #   AttributePerson.inheritance_column
        
      
        

          
          
                #   # => 'address_id'
        
      
        

          1
          
                def define_attr_method(name, value=nil, &block)
        
      
        

          
          
                  sing = singleton_class
        
      
        

          
          
                  sing.class_eval <<-eorb, __FILE__, __LINE__ + 1
        
      
        

          
          
                    if method_defined?('original_#{name}')
        
      
        

          
          
                      undef :'original_#{name}'
        
      
        

          
          
                    end
        
      
        

          
          
                    alias_method :'original_#{name}', :'#{name}'
        
      
        

          
          
                  eorb
        
      
        

          
          
                  if block_given?
        
      
        

          
          
                    sing.send :define_method, name, &block
        
      
        

          
          
                  else
        
      
        

          
          
                    # If we can compile the method name, do it. Otherwise use define_method.
        
      
        

          
          
                    # This is an important *optimization*, please don't change it. define_method
        
      
        

          
          
                    # has slower dispatch and consumes more memory.
        
      
        

          
          
                    if name =~ COMPILABLE_REGEXP
        
      
        

          
          
                      sing.class_eval <<-RUBY, __FILE__, __LINE__ + 1
        
      
        

          
          
                        def #{name}; #{value.nil? ? 'nil' : value.to_s.inspect}; end
        
      
        

          
          
                      RUBY
        
      
        

          
          
                    else
        
      
        

          
          
                      value = value.to_s if value
        
      
        

          
          
                      sing.send(:define_method, name) { value }
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Declares a method available for all attributes with the given prefix.
        
      
        

          
          
                # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
        
      
        

          
          
                #
        
      
        

          
          
                #   #{prefix}#{attr}(*args, &block)
        
      
        

          
          
                #
        
      
        

          
          
                # to
        
      
        

          
          
                #
        
      
        

          
          
                #   #{prefix}attribute(#{attr}, *args, &block)
        
      
        

          
          
                #
        
      
        

          
          
                # An instance method <tt>#{prefix}attribute</tt> must exist and accept
        
      
        

          
          
                # at least the +attr+ argument.
        
      
        

          
          
                #
        
      
        

          
          
                # For example:
        
      
        

          
          
                #
        
      
        

          
          
                #   class Person
        
      
        

          
          
                #
        
      
        

          
          
                #     include ActiveModel::AttributeMethods
        
      
        

          
          
                #     attr_accessor :name
        
      
        

          
          
                #     attribute_method_prefix 'clear_'
        
      
        

          
          
                #     define_attribute_methods [:name]
        
      
        

          
          
                #
        
      
        

          
          
                #     private
        
      
        

          
          
                #
        
      
        

          
          
                #     def clear_attribute(attr)
        
      
        

          
          
                #       send("#{attr}=", nil)
        
      
        

          
          
                #     end
        
      
        

          
          
                #   end
        
      
        

          
          
                #
        
      
        

          
          
                #   person = Person.new
        
      
        

          
          
                #   person.name = "Bob"
        
      
        

          
          
                #   person.name          # => "Bob"
        
      
        

          
          
                #   person.clear_name
        
      
        

          
          
                #   person.name          # => nil
        
      
        

          1
          
                def attribute_method_prefix(*prefixes)
        
      
        

          
          
                  self.attribute_method_matchers += prefixes.map { |prefix| AttributeMethodMatcher.new :prefix => prefix }
        
      
        

          
          
                  undefine_attribute_methods
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Declares a method available for all attributes with the given suffix.
        
      
        

          
          
                # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
        
      
        

          
          
                #
        
      
        

          
          
                #   #{attr}#{suffix}(*args, &block)
        
      
        

          
          
                #
        
      
        

          
          
                # to
        
      
        

          
          
                #
        
      
        

          
          
                #   attribute#{suffix}(#{attr}, *args, &block)
        
      
        

          
          
                #
        
      
        

          
          
                # An <tt>attribute#{suffix}</tt> instance method must exist and accept at least
        
      
        

          
          
                # the +attr+ argument.
        
      
        

          
          
                #
        
      
        

          
          
                # For example:
        
      
        

          
          
                #
        
      
        

          
          
                #   class Person
        
      
        

          
          
                #
        
      
        

          
          
                #     include ActiveModel::AttributeMethods
        
      
        

          
          
                #     attr_accessor :name
        
      
        

          
          
                #     attribute_method_suffix '_short?'
        
      
        

          
          
                #     define_attribute_methods [:name]
        
      
        

          
          
                #
        
      
        

          
          
                #     private
        
      
        

          
          
                #
        
      
        

          
          
                #     def attribute_short?(attr)
        
      
        

          
          
                #       send(attr).length < 5
        
      
        

          
          
                #     end
        
      
        

          
          
                #   end
        
      
        

          
          
                #
        
      
        

          
          
                #   person = Person.new
        
      
        

          
          
                #   person.name = "Bob"
        
      
        

          
          
                #   person.name          # => "Bob"
        
      
        

          
          
                #   person.name_short?   # => true
        
      
        

          1
          
                def attribute_method_suffix(*suffixes)
        
      
        

          
          
                  self.attribute_method_matchers += suffixes.map { |suffix| AttributeMethodMatcher.new :suffix => suffix }
        
      
        

          
          
                  undefine_attribute_methods
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Declares a method available for all attributes with the given prefix
        
      
        

          
          
                # and suffix. Uses +method_missing+ and <tt>respond_to?</tt> to rewrite
        
      
        

          
          
                # the method.
        
      
        

          
          
                #
        
      
        

          
          
                #   #{prefix}#{attr}#{suffix}(*args, &block)
        
      
        

          
          
                #
        
      
        

          
          
                # to
        
      
        

          
          
                #
        
      
        

          
          
                #   #{prefix}attribute#{suffix}(#{attr}, *args, &block)
        
      
        

          
          
                #
        
      
        

          
          
                # An <tt>#{prefix}attribute#{suffix}</tt> instance method must exist and
        
      
        

          
          
                # accept at least the +attr+ argument.
        
      
        

          
          
                #
        
      
        

          
          
                # For example:
        
      
        

          
          
                #
        
      
        

          
          
                #   class Person
        
      
        

          
          
                #
        
      
        

          
          
                #     include ActiveModel::AttributeMethods
        
      
        

          
          
                #     attr_accessor :name
        
      
        

          
          
                #     attribute_method_affix :prefix => 'reset_', :suffix => '_to_default!'
        
      
        

          
          
                #     define_attribute_methods [:name]
        
      
        

          
          
                #
        
      
        

          
          
                #     private
        
      
        

          
          
                #
        
      
        

          
          
                #     def reset_attribute_to_default!(attr)
        
      
        

          
          
                #       ...
        
      
        

          
          
                #     end
        
      
        

          
          
                #   end
        
      
        

          
          
                #
        
      
        

          
          
                #   person = Person.new
        
      
        

          
          
                #   person.name                         # => 'Gem'
        
      
        

          
          
                #   person.reset_name_to_default!
        
      
        

          
          
                #   person.name                         # => 'Gemma'
        
      
        

          1
          
                def attribute_method_affix(*affixes)
        
      
        

          
          
                  self.attribute_method_matchers += affixes.map { |affix| AttributeMethodMatcher.new :prefix => affix[:prefix], :suffix => affix[:suffix] }
        
      
        

          
          
                  undefine_attribute_methods
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def alias_attribute(new_name, old_name)
        
      
        

          
          
                  attribute_method_matchers.each do |matcher|
        
      
        

          
          
                    matcher_new = matcher.method_name(new_name).to_s
        
      
        

          
          
                    matcher_old = matcher.method_name(old_name).to_s
        
      
        

          
          
          
        
      
        

          
          
                    if matcher_new =~ COMPILABLE_REGEXP && matcher_old =~ COMPILABLE_REGEXP
        
      
        

          
          
                      module_eval <<-RUBY, __FILE__, __LINE__ + 1
        
      
        

          
          
                        def #{matcher_new}(*args)
        
      
        

          
          
                          send(:#{matcher_old}, *args)
        
      
        

          
          
                        end
        
      
        

          
          
                      RUBY
        
      
        

          
          
                    else
        
      
        

          
          
                      define_method(matcher_new) do |*args|
        
      
        

          
          
                        send(matcher_old, *args)
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Declares the attributes that should be prefixed and suffixed by
        
      
        

          
          
                # ActiveModel::AttributeMethods.
        
      
        

          
          
                #
        
      
        

          
          
                # To use, pass in an array of attribute names (as strings or symbols),
        
      
        

          
          
                # be sure to declare +define_attribute_methods+ after you define any
        
      
        

          
          
                # prefix, suffix or affix methods, or they will not hook in.
        
      
        

          
          
                #
        
      
        

          
          
                #   class Person
        
      
        

          
          
                #
        
      
        

          
          
                #     include ActiveModel::AttributeMethods
        
      
        

          
          
                #     attr_accessor :name, :age, :address
        
      
        

          
          
                #     attribute_method_prefix 'clear_'
        
      
        

          
          
                #
        
      
        

          
          
                #     # Call to define_attribute_methods must appear after the
        
      
        

          
          
                #     # attribute_method_prefix, attribute_method_suffix or
        
      
        

          
          
                #     # attribute_method_affix declares.
        
      
        

          
          
                #     define_attribute_methods [:name, :age, :address]
        
      
        

          
          
                #
        
      
        

          
          
                #     private
        
      
        

          
          
                #
        
      
        

          
          
                #     def clear_attribute(attr)
        
      
        

          
          
                #       ...
        
      
        

          
          
                #     end
        
      
        

          
          
                #   end
        
      
        

          1
          
                def define_attribute_methods(attr_names)
        
      
        

          
          
                  attr_names.each { |attr_name| define_attribute_method(attr_name) }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def define_attribute_method(attr_name)
        
      
        

          
          
                  attribute_method_matchers.each do |matcher|
        
      
        

          
          
                    unless instance_method_already_implemented?(matcher.method_name(attr_name))
        
      
        

          
          
                      generate_method = "define_method_#{matcher.prefix}attribute#{matcher.suffix}"
        
      
        

          
          
          
        
      
        

          
          
                      if respond_to?(generate_method)
        
      
        

          
          
                        send(generate_method, attr_name)
        
      
        

          
          
                      else
        
      
        

          
          
                        method_name = matcher.method_name(attr_name)
        
      
        

          
          
          
        
      
        

          
          
                        generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
        
      
        

          
          
                          if method_defined?('#{method_name}')
        
      
        

          
          
                            undef :'#{method_name}'
        
      
        

          
          
                          end
        
      
        

          
          
                        RUBY
        
      
        

          
          
          
        
      
        

          
          
                        if method_name.to_s =~ COMPILABLE_REGEXP
        
      
        

          
          
                          generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
        
      
        

          
          
                            def #{method_name}(*args)
        
      
        

          
          
                              send(:#{matcher.method_missing_target}, '#{attr_name}', *args)
        
      
        

          
          
                            end
        
      
        

          
          
                          RUBY
        
      
        

          
          
                        else
        
      
        

          
          
                          generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
        
      
        

          
          
                            define_method('#{method_name}') do |*args|
        
      
        

          
          
                              send('#{matcher.method_missing_target}', '#{attr_name}', *args)
        
      
        

          
          
                            end
        
      
        

          
          
                          RUBY
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Removes all the previously dynamically defined methods from the class
        
      
        

          1
          
                def undefine_attribute_methods
        
      
        

          
          
                  generated_attribute_methods.module_eval do
        
      
        

          
          
                    instance_methods.each { |m| undef_method(m) }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns true if the attribute methods defined have been generated.
        
      
        

          1
          
                def generated_attribute_methods #:nodoc:
        
      
        

          
          
                  @generated_attribute_methods ||= begin
        
      
        

          
          
                    mod = Module.new
        
      
        

          
          
                    include mod
        
      
        

          
          
                    mod
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                protected
        
      
        

          1
          
                  def instance_method_already_implemented?(method_name)
        
      
        

          
          
                    method_defined?(method_name)
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          1
          
                private
        
      
        

          1
          
                  class AttributeMethodMatcher
        
      
        

          1
          
                    attr_reader :prefix, :suffix, :method_missing_target
        
      
        

          
          
          
        
      
        

          1
          
                    AttributeMethodMatch = Struct.new(:target, :attr_name)
        
      
        

          
          
          
        
      
        

          1
          
                    def initialize(options = {})
        
      
        

          
          
                      options.symbolize_keys!
        
      
        

          
          
                      @prefix, @suffix = options[:prefix] || '', options[:suffix] || ''
        
      
        

          
          
                      @regex = /^(#{Regexp.escape(@prefix)})(.+?)(#{Regexp.escape(@suffix)})$/
        
      
        

          
          
                      @method_missing_target = "#{@prefix}attribute#{@suffix}"
        
      
        

          
          
                      @method_name = "#{prefix}%s#{suffix}"
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          1
          
                    def match(method_name)
        
      
        

          
          
                      if @regex =~ method_name
        
      
        

          
          
                        AttributeMethodMatch.new(method_missing_target, $2)
        
      
        

          
          
                      else
        
      
        

          
          
                        nil
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          1
          
                    def method_name(attr_name)
        
      
        

          
          
                      @method_name % attr_name
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Allows access to the object attributes, which are held in the
        
      
        

          
          
              # <tt>@attributes</tt> hash, as though they were first-class methods. So a
        
      
        

          
          
              # Person class with a name attribute can use Person#name and Person#name=
        
      
        

          
          
              # and never directly use the attributes hash -- except for multiple assigns
        
      
        

          
          
              # with ActiveRecord#attributes=. A Milestone class can also ask
        
      
        

          
          
              # Milestone#completed? to test that the completed attribute is not +nil+
        
      
        

          
          
              # or 0.
        
      
        

          
          
              #
        
      
        

          
          
              # It's also possible to instantiate related objects, so a Client class
        
      
        

          
          
              # belonging to the clients table with a +master_id+ foreign key can
        
      
        

          
          
              # instantiate master through Client#master.
        
      
        

          1
          
              def method_missing(method_id, *args, &block)
        
      
        

          
          
                method_name = method_id.to_s
        
      
        

          
          
                if match = match_attribute_method?(method_name)
        
      
        

          
          
                  guard_private_attribute_method!(method_name, args)
        
      
        

          
          
                  return __send__(match.target, match.attr_name, *args, &block)
        
      
        

          
          
                end
        
      
        

          
          
                super
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # A Person object with a name attribute can ask <tt>person.respond_to?(:name)</tt>,
        
      
        

          
          
              # <tt>person.respond_to?(:name=)</tt>, and <tt>person.respond_to?(:name?)</tt>
        
      
        

          
          
              # which will all return +true+.
        
      
        

          1
          
              alias :respond_to_without_attributes? :respond_to?
        
      
        

          1
          
              def respond_to?(method, include_private_methods = false)
        
      
        

          
          
                if super
        
      
        

          
          
                  return true
        
      
        

          
          
                elsif !include_private_methods && super(method, true)
        
      
        

          
          
                  # If we're here then we haven't found among non-private methods
        
      
        

          
          
                  # but found among all methods. Which means that the given method is private.
        
      
        

          
          
                  return false
        
      
        

          
          
                elsif match_attribute_method?(method.to_s)
        
      
        

          
          
                  return true
        
      
        

          
          
                end
        
      
        

          
          
                super
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              protected
        
      
        

          1
          
                def attribute_method?(attr_name)
        
      
        

          
          
                  attributes.include?(attr_name)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
              private
        
      
        

          
          
                # Returns a struct representing the matching attribute method.
        
      
        

          
          
                # The struct's attributes are prefix, base and suffix.
        
      
        

          1
          
                def match_attribute_method?(method_name)
        
      
        

          
          
                  self.class.attribute_method_matchers.each do |method|
        
      
        

          
          
                    if (match = method.match(method_name)) && attribute_method?(match.attr_name)
        
      
        

          
          
                      return match
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                  nil
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # prevent method_missing from calling private methods with #send
        
      
        

          1
          
                def guard_private_attribute_method!(method_name, args)
        
      
        

          
          
                  if self.class.private_method_defined?(method_name)
        
      
        

          
          
                    raise NoMethodError.new("Attempt to call private method `#{method_name}'", method_name, args)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def missing_attribute(attr_name, stack)
        
      
        

          
          
                  raise ActiveModel::MissingAttributeError, "missing attribute: #{attr_name}", stack
        
      
        

          
          
                end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require "active_model"
        
      
        

          1
          
          require "rails"
        
      
    
  

    

      
        

          
          
          #--
        
      
        

          
          
          # Copyright (c) 2004-2011 David Heinemeier Hansson
        
      
        

          
          
          #
        
      
        

          
          
          # Permission is hereby granted, free of charge, to any person obtaining
        
      
        

          
          
          # a copy of this software and associated documentation files (the
        
      
        

          
          
          # "Software"), to deal in the Software without restriction, including
        
      
        

          
          
          # without limitation the rights to use, copy, modify, merge, publish,
        
      
        

          
          
          # distribute, sublicense, and/or sell copies of the Software, and to
        
      
        

          
          
          # permit persons to whom the Software is furnished to do so, subject to
        
      
        

          
          
          # the following conditions:
        
      
        

          
          
          #
        
      
        

          
          
          # The above copyright notice and this permission notice shall be
        
      
        

          
          
          # included in all copies or substantial portions of the Software.
        
      
        

          
          
          #
        
      
        

          
          
          # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
        
      
        

          
          
          # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        
      
        

          
          
          # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
        
      
        

          
          
          # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
        
      
        

          
          
          # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
        
      
        

          
          
          # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
        
      
        

          
          
          # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
        
      
        

          
          
          #++
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
          activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
        
      
        

          1
          
          $:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
        
      
        

          
          
          
        
      
        

          1
          
          activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
        
      
        

          1
          
          $:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
        
      
        

          
          
          
        
      
        

          1
          
          require 'active_support'
        
      
        

          1
          
          require 'active_support/i18n'
        
      
        

          1
          
          require 'active_model'
        
      
        

          1
          
          require 'arel'
        
      
        

          
          
          
        
      
        

          1
          
          require 'active_record/version'
        
      
        

          
          
          
        
      
        

          1
          
          module ActiveRecord
        
      
        

          1
          
            extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
            eager_autoload do
        
      
        

          1
          
              autoload :ActiveRecordError, 'active_record/errors'
        
      
        

          1
          
              autoload :ConnectionNotEstablished, 'active_record/errors'
        
      
        

          
          
          
        
      
        

          1
          
              autoload :Aggregations
        
      
        

          1
          
              autoload :Associations
        
      
        

          1
          
              autoload :AttributeMethods
        
      
        

          1
          
              autoload :AutosaveAssociation
        
      
        

          
          
          
        
      
        

          1
          
              autoload :Relation
        
      
        

          
          
          
        
      
        

          1
          
              autoload_under 'relation' do
        
      
        

          1
          
                autoload :QueryMethods
        
      
        

          1
          
                autoload :FinderMethods
        
      
        

          1
          
                autoload :Calculations
        
      
        

          1
          
                autoload :PredicateBuilder
        
      
        

          1
          
                autoload :SpawnMethods
        
      
        

          1
          
                autoload :Batches
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              autoload :Base
        
      
        

          1
          
              autoload :Callbacks
        
      
        

          1
          
              autoload :CounterCache
        
      
        

          1
          
              autoload :DynamicFinderMatch
        
      
        

          1
          
              autoload :DynamicScopeMatch
        
      
        

          1
          
              autoload :Migration
        
      
        

          1
          
              autoload :Migrator, 'active_record/migration'
        
      
        

          1
          
              autoload :NamedScope
        
      
        

          1
          
              autoload :NestedAttributes
        
      
        

          1
          
              autoload :Observer
        
      
        

          1
          
              autoload :Persistence
        
      
        

          1
          
              autoload :QueryCache
        
      
        

          1
          
              autoload :Reflection
        
      
        

          1
          
              autoload :Schema
        
      
        

          1
          
              autoload :SchemaDumper
        
      
        

          1
          
              autoload :Serialization
        
      
        

          1
          
              autoload :SessionStore
        
      
        

          1
          
              autoload :Timestamp
        
      
        

          1
          
              autoload :Transactions
        
      
        

          1
          
              autoload :Validations
        
      
        

          1
          
              autoload :IdentityMap
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            module Coders
        
      
        

          1
          
              autoload :YAMLColumn, 'active_record/coders/yaml_column'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            module AttributeMethods
        
      
        

          1
          
              extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
              eager_autoload do
        
      
        

          1
          
                autoload :BeforeTypeCast
        
      
        

          1
          
                autoload :Dirty
        
      
        

          1
          
                autoload :PrimaryKey
        
      
        

          1
          
                autoload :Query
        
      
        

          1
          
                autoload :Read
        
      
        

          1
          
                autoload :TimeZoneConversion
        
      
        

          1
          
                autoload :Write
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            module Locking
        
      
        

          1
          
              extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
              eager_autoload do
        
      
        

          1
          
                autoload :Optimistic
        
      
        

          1
          
                autoload :Pessimistic
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            module ConnectionAdapters
        
      
        

          1
          
              extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
              eager_autoload do
        
      
        

          1
          
                autoload :AbstractAdapter
        
      
        

          1
          
                autoload :ConnectionManagement, "active_record/connection_adapters/abstract/connection_pool"
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            autoload :TestCase
        
      
        

          1
          
            autoload :TestFixtures, 'active_record/fixtures'
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          ActiveSupport.on_load(:active_record) do
        
      
        

          
          
            Arel::Table.engine = self
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
        
      
    
  

    

      
        

          1
          
          require 'active_support/core_ext/enumerable'
        
      
        

          
          
          
        
      
        

          1
          
          module ActiveRecord
        
      
        

          
          
            # = Active Record Attribute Methods
        
      
        

          1
          
            module AttributeMethods #:nodoc:
        
      
        

          1
          
              extend ActiveSupport::Concern
        
      
        

          1
          
              include ActiveModel::AttributeMethods
        
      
        

          
          
          
        
      
        

          1
          
              module ClassMethods
        
      
        

          
          
                # Generates all the attribute related methods for columns in the database
        
      
        

          
          
                # accessors, mutators and query methods.
        
      
        

          1
          
                def define_attribute_methods
        
      
        

          
          
                  return if attribute_methods_generated?
        
      
        

          
          
                  super(column_names)
        
      
        

          
          
                  @attribute_methods_generated = true
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def attribute_methods_generated?
        
      
        

          
          
                  @attribute_methods_generated ||= false
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def undefine_attribute_methods(*args)
        
      
        

          
          
                  super
        
      
        

          
          
                  @attribute_methods_generated = false
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Checks whether the method is defined in the model or any of its subclasses
        
      
        

          
          
                # that also derive from Active Record. Raises DangerousAttributeError if the
        
      
        

          
          
                # method is defined by Active Record though.
        
      
        

          1
          
                def instance_method_already_implemented?(method_name)
        
      
        

          
          
                  method_name = method_name.to_s
        
      
        

          
          
                  index = ancestors.index(ActiveRecord::Base) || ancestors.length
        
      
        

          
          
                  @_defined_class_methods         ||= ancestors.first(index).map { |m|
        
      
        

          
          
                    m.instance_methods(false) | m.private_instance_methods(false)
        
      
        

          
          
                  }.flatten.map {|m| m.to_s }.to_set
        
      
        

          
          
          
        
      
        

          
          
                  @@_defined_activerecord_methods ||= defined_activerecord_methods
        
      
        

          
          
                  raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord" if @@_defined_activerecord_methods.include?(method_name)
        
      
        

          
          
                  @_defined_class_methods.include?(method_name)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def defined_activerecord_methods
        
      
        

          
          
                  active_record = ActiveRecord::Base
        
      
        

          
          
                  super_klass   = ActiveRecord::Base.superclass
        
      
        

          
          
                  methods = (active_record.instance_methods - super_klass.instance_methods) +
        
      
        

          
          
                            (active_record.private_instance_methods - super_klass.private_instance_methods)
        
      
        

          
          
                  methods.map {|m| m.to_s }.to_set
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def method_missing(method_id, *args, &block)
        
      
        

          
          
                # If we haven't generated any methods yet, generate them, then
        
      
        

          
          
                # see if we've created the method we're looking for.
        
      
        

          
          
                if !self.class.attribute_methods_generated?
        
      
        

          
          
                  self.class.define_attribute_methods
        
      
        

          
          
                  method_name = method_id.to_s
        
      
        

          
          
                  guard_private_attribute_method!(method_name, args)
        
      
        

          
          
                  send(method_id, *args, &block)
        
      
        

          
          
                else
        
      
        

          
          
                  super
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def respond_to?(name, include_private = false)
        
      
        

          
          
                self.class.define_attribute_methods unless self.class.attribute_methods_generated?
        
      
        

          
          
                super
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              protected
        
      
        

          1
          
                def attribute_method?(attr_name)
        
      
        

          
          
                  attr_name == 'id' || (defined?(@attributes) && @attributes.include?(attr_name))
        
      
        

          
          
                end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require "active_record"
        
      
        

          1
          
          require "rails"
        
      
        

          1
          
          require "active_model/railtie"
        
      
        

          
          
          
        
      
        

          
          
          # For now, action_controller must always be present with
        
      
        

          
          
          # rails, so let's make sure that it gets required before
        
      
        

          
          
          # here. This is needed for correctly setting up the middleware.
        
      
        

          
          
          # In the future, this might become an optional require.
        
      
        

          1
          
          require "action_controller/railtie"
        
      
        

          
          
          
        
      
        

          1
          
          module ActiveRecord
        
      
        

          
          
            # = Active Record Railtie
        
      
        

          1
          
            class Railtie < Rails::Railtie
        
      
        

          1
          
              config.active_record = ActiveSupport::OrderedOptions.new
        
      
        

          
          
          
        
      
        

          1
          
              config.app_generators.orm :active_record, :migration => true,
        
      
        

          
          
                                                        :timestamps => true
        
      
        

          
          
          
        
      
        

          1
          
              config.app_middleware.insert_after "::ActionDispatch::Callbacks",
        
      
        

          
          
                "ActiveRecord::QueryCache"
        
      
        

          
          
          
        
      
        

          1
          
              config.app_middleware.insert_after "::ActionDispatch::Callbacks",
        
      
        

          
          
                "ActiveRecord::ConnectionAdapters::ConnectionManagement"
        
      
        

          
          
          
        
      
        

          1
          
              rake_tasks do
        
      
        

          
          
                load "active_record/railties/databases.rake"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # When loading console, force ActiveRecord::Base to be loaded
        
      
        

          
          
              # to avoid cross references when loading a constant for the
        
      
        

          
          
              # first time. Also, make it output to STDERR.
        
      
        

          1
          
              console do |app|
        
      
        

          
          
                require "active_record/railties/console_sandbox" if app.sandbox?
        
      
        

          
          
                ActiveRecord::Base.logger = Logger.new(STDERR)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "active_record.initialize_timezone" do
        
      
        

          
          
                ActiveSupport.on_load(:active_record) do
        
      
        

          
          
                  self.time_zone_aware_attributes = true
        
      
        

          
          
                  self.default_timezone = :utc
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "active_record.logger" do
        
      
        

          
          
                ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "active_record.identity_map" do |app|
        
      
        

          
          
                config.app_middleware.insert_after "::ActionDispatch::Callbacks",
        
      
        

          
          
                  "ActiveRecord::IdentityMap::Middleware" if config.active_record.delete(:identity_map)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "active_record.set_configs" do |app|
        
      
        

          
          
                ActiveSupport.on_load(:active_record) do
        
      
        

          
          
                  if app.config.active_record.delete(:whitelist_attributes)
        
      
        

          
          
                    attr_accessible(nil)
        
      
        

          
          
                  end
        
      
        

          
          
                  app.config.active_record.each do |k,v|
        
      
        

          
          
                    send "#{k}=", v
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # This sets the database configuration from Configuration#database_configuration
        
      
        

          
          
              # and then establishes the connection.
        
      
        

          1
          
              initializer "active_record.initialize_database" do |app|
        
      
        

          
          
                ActiveSupport.on_load(:active_record) do
        
      
        

          
          
                  self.configurations = app.config.database_configuration
        
      
        

          
          
                  establish_connection
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Expose database runtime to controller for logging.
        
      
        

          1
          
              initializer "active_record.log_runtime" do |app|
        
      
        

          
          
                require "active_record/railties/controller_runtime"
        
      
        

          
          
                ActiveSupport.on_load(:action_controller) do
        
      
        

          
          
                  include ActiveRecord::Railties::ControllerRuntime
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              initializer "active_record.set_dispatch_hooks", :before => :set_clear_dependencies_hook do |app|
        
      
        

          
          
                ActiveSupport.on_load(:active_record) do
        
      
        

          
          
                  ActionDispatch::Reloader.to_cleanup do
        
      
        

          
          
                    ActiveRecord::Base.clear_reloadable_connections!
        
      
        

          
          
                    ActiveRecord::Base.clear_cache!
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              config.after_initialize do
        
      
        

          
          
                ActiveSupport.on_load(:active_record) do
        
      
        

          
          
                  instantiate_observers
        
      
        

          
          
          
        
      
        

          
          
                  ActionDispatch::Reloader.to_prepare do
        
      
        

          
          
                    ActiveRecord::Base.instantiate_observers
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              config.after_initialize do
        
      
        

          
          
                container  = :"activerecord.attributes"
        
      
        

          
          
                lookup = I18n.t(container, :default => {})
        
      
        

          
          
                if lookup.is_a?(Hash)
        
      
        

          
          
                  lookup.each do |key, value| 
        
      
        

          
          
                    if value.is_a?(Hash) && value.any? { |k,v| v.is_a?(Hash) }
        
      
        

          
          
                      $stderr.puts "[DEPRECATION WARNING] Nested I18n namespace lookup under \"#{container}.#{key}\" is no longer supported"
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                container  = :"activerecord.models"
        
      
        

          
          
                lookup = I18n.t(container, :default => {})
        
      
        

          
          
                if lookup.is_a?(Hash)
        
      
        

          
          
                  lookup.each do |key, value|
        
      
        

          
          
                    if value.is_a?(Hash) && !value.key?(:one)
        
      
        

          
          
                      $stderr.puts "[DEPRECATION WARNING] Nested I18n namespace lookup under \"#{container}.#{key}\" is no longer supported"
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module ActiveRecord
        
      
        

          1
          
            module VERSION #:nodoc:
        
      
        

          1
          
              MAJOR = 3
        
      
        

          1
          
              MINOR = 1
        
      
        

          1
          
              TINY  = 0
        
      
        

          1
          
              PRE   = nil
        
      
        

          
          
          
        
      
        

          1
          
              STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #--
        
      
        

          
          
          # Copyright (c) 2006-2011 David Heinemeier Hansson
        
      
        

          
          
          #
        
      
        

          
          
          # Permission is hereby granted, free of charge, to any person obtaining
        
      
        

          
          
          # a copy of this software and associated documentation files (the
        
      
        

          
          
          # "Software"), to deal in the Software without restriction, including
        
      
        

          
          
          # without limitation the rights to use, copy, modify, merge, publish,
        
      
        

          
          
          # distribute, sublicense, and/or sell copies of the Software, and to
        
      
        

          
          
          # permit persons to whom the Software is furnished to do so, subject to
        
      
        

          
          
          # the following conditions:
        
      
        

          
          
          #
        
      
        

          
          
          # The above copyright notice and this permission notice shall be
        
      
        

          
          
          # included in all copies or substantial portions of the Software.
        
      
        

          
          
          #
        
      
        

          
          
          # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
        
      
        

          
          
          # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        
      
        

          
          
          # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
        
      
        

          
          
          # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
        
      
        

          
          
          # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
        
      
        

          
          
          # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
        
      
        

          
          
          # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
        
      
        

          
          
          #++
        
      
        

          
          
          
        
      
        

          1
          
          activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
        
      
        

          1
          
          $:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
        
      
        

          
          
          
        
      
        

          1
          
          activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
        
      
        

          1
          
          $:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
        
      
        

          
          
          
        
      
        

          1
          
          require 'active_support'
        
      
        

          1
          
          require 'active_model'
        
      
        

          1
          
          require 'active_resource/version'
        
      
        

          
          
          
        
      
        

          1
          
          module ActiveResource
        
      
        

          1
          
            extend ActiveSupport::Autoload
        
      
        

          
          
          
        
      
        

          1
          
            autoload :Base
        
      
        

          1
          
            autoload :Connection
        
      
        

          1
          
            autoload :CustomMethods
        
      
        

          1
          
            autoload :Formats
        
      
        

          1
          
            autoload :HttpMock
        
      
        

          1
          
            autoload :Observing
        
      
        

          1
          
            autoload :Schema
        
      
        

          1
          
            autoload :Validations
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require "active_resource"
        
      
        

          1
          
          require "rails"
        
      
        

          
          
          
        
      
        

          1
          
          module ActiveResource
        
      
        

          1
          
            class Railtie < Rails::Railtie
        
      
        

          1
          
              config.active_resource = ActiveSupport::OrderedOptions.new
        
      
        

          
          
          
        
      
        

          1
          
              initializer "active_resource.set_configs" do |app|
        
      
        

          
          
                app.config.active_resource.each do |k,v|
        
      
        

          
          
                  ActiveResource::Base.send "#{k}=", v
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module ActiveResource
        
      
        

          1
          
            module VERSION #:nodoc:
        
      
        

          1
          
              MAJOR = 3
        
      
        

          1
          
              MINOR = 1
        
      
        

          1
          
              TINY  = 0
        
      
        

          1
          
              PRE   = nil
        
      
        

          
          
          
        
      
        

          1
          
              STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module ActiveSupport
        
      
        

          1
          
            if defined? ::BasicObject
        
      
        

          
          
              # A class with no predefined methods that behaves similarly to Builder's
        
      
        

          
          
              # BlankSlate. Used for proxy classes.
        
      
        

          1
          
              class BasicObject < ::BasicObject
        
      
        

          1
          
                undef_method :==
        
      
        

          1
          
                undef_method :equal?
        
      
        

          
          
          
        
      
        

          
          
                # Let ActiveSupport::BasicObject at least raise exceptions.
        
      
        

          1
          
                def raise(*args)
        
      
        

          
          
                  ::Object.send(:raise, *args)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            else
        
      
        

          
          
              class BasicObject #:nodoc:
        
      
        

          
          
                instance_methods.each do |m|
        
      
        

          
          
                  undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$)/
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class Array
        
      
        

          
          
            # Returns an unique array based on the criteria given as a +Proc+.
        
      
        

          
          
            #
        
      
        

          
          
            #   [1, 2, 3, 4].uniq_by { |i| i.odd? } # => [1, 2]
        
      
        

          
          
            #
        
      
        

          1
          
            def uniq_by
        
      
        

          
          
              hash, array = {}, []
        
      
        

          
          
              each { |i| hash[yield(i)] ||= (array << i) }
        
      
        

          
          
              array
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Same as uniq_by, but modifies self.
        
      
        

          1
          
            def uniq_by!
        
      
        

          
          
              replace(uniq_by{ |i| yield(i) })
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'active_support/core_ext/class/attribute'
        
      
        

          1
          
          require 'active_support/core_ext/class/attribute_accessors'
        
      
        

          1
          
          require 'active_support/core_ext/class/inheritable_attributes'
        
      
        

          1
          
          require 'active_support/core_ext/class/delegating_attributes'
        
      
        

          1
          
          require 'active_support/core_ext/class/subclasses'
        
      
    
  

    

      
        

          1
          
          require 'active_support/core_ext/kernel/singleton_class'
        
      
        

          1
          
          require 'active_support/core_ext/module/remove_method'
        
      
        

          1
          
          require 'active_support/core_ext/array/extract_options'
        
      
        

          
          
          
        
      
        

          1
          
          class Class
        
      
        

          
          
            # Declare a class-level attribute whose value is inheritable by subclasses.
        
      
        

          
          
            # Subclasses can change their own value and it will not impact parent class.
        
      
        

          
          
            #
        
      
        

          
          
            #   class Base
        
      
        

          
          
            #     class_attribute :setting
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            #   class Subclass < Base
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            #   Base.setting = true
        
      
        

          
          
            #   Subclass.setting            # => true
        
      
        

          
          
            #   Subclass.setting = false
        
      
        

          
          
            #   Subclass.setting            # => false
        
      
        

          
          
            #   Base.setting                # => true
        
      
        

          
          
            #
        
      
        

          
          
            # In the above case as long as Subclass does not assign a value to setting
        
      
        

          
          
            # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
        
      
        

          
          
            # would read value assigned to parent class. Once Subclass assigns a value then
        
      
        

          
          
            # the value assigned by Subclass would be returned.
        
      
        

          
          
            #
        
      
        

          
          
            # This matches normal Ruby method inheritance: think of writing an attribute
        
      
        

          
          
            # on a subclass as overriding the reader method. However, you need to be aware
        
      
        

          
          
            # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
        
      
        

          
          
            # In such cases, you don't want to do changes in places but use setters:
        
      
        

          
          
            #
        
      
        

          
          
            #   Base.setting = []
        
      
        

          
          
            #   Base.setting                # => []
        
      
        

          
          
            #   Subclass.setting            # => []
        
      
        

          
          
            #
        
      
        

          
          
            #   # Appending in child changes both parent and child because it is the same object:
        
      
        

          
          
            #   Subclass.setting << :foo
        
      
        

          
          
            #   Base.setting               # => [:foo]
        
      
        

          
          
            #   Subclass.setting           # => [:foo]
        
      
        

          
          
            #
        
      
        

          
          
            #   # Use setters to not propagate changes:
        
      
        

          
          
            #   Base.setting = []
        
      
        

          
          
            #   Subclass.setting += [:foo]
        
      
        

          
          
            #   Base.setting               # => []
        
      
        

          
          
            #   Subclass.setting           # => [:foo]
        
      
        

          
          
            #
        
      
        

          
          
            # For convenience, a query method is defined as well:
        
      
        

          
          
            #
        
      
        

          
          
            #   Subclass.setting?       # => false
        
      
        

          
          
            #
        
      
        

          
          
            # Instances may overwrite the class value in the same way:
        
      
        

          
          
            #
        
      
        

          
          
            #   Base.setting = true
        
      
        

          
          
            #   object = Base.new
        
      
        

          
          
            #   object.setting          # => true
        
      
        

          
          
            #   object.setting = false
        
      
        

          
          
            #   object.setting          # => false
        
      
        

          
          
            #   Base.setting            # => true
        
      
        

          
          
            #
        
      
        

          
          
            # To opt out of the instance reader method, pass :instance_reader => false.
        
      
        

          
          
            #
        
      
        

          
          
            #   object.setting          # => NoMethodError
        
      
        

          
          
            #   object.setting?         # => NoMethodError
        
      
        

          
          
            #
        
      
        

          
          
            # To opt out of the instance writer method, pass :instance_writer => false.
        
      
        

          
          
            #
        
      
        

          
          
            #   object.setting = false  # => NoMethodError
        
      
        

          1
          
            def class_attribute(*attrs)
        
      
        

          
          
              options = attrs.extract_options!
        
      
        

          
          
              instance_reader = options.fetch(:instance_reader, true)
        
      
        

          
          
              instance_writer = options.fetch(:instance_writer, true)
        
      
        

          
          
          
        
      
        

          
          
              attrs.each do |name|
        
      
        

          
          
                class_eval <<-RUBY, __FILE__, __LINE__ + 1
        
      
        

          
          
                  def self.#{name}() nil end
        
      
        

          
          
                  def self.#{name}?() !!#{name} end
        
      
        

          
          
          
        
      
        

          
          
                  def self.#{name}=(val)
        
      
        

          
          
                    singleton_class.class_eval do
        
      
        

          
          
                      remove_possible_method(:#{name})
        
      
        

          
          
                      define_method(:#{name}) { val }
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                    if singleton_class?
        
      
        

          
          
                      class_eval do
        
      
        

          
          
                        remove_possible_method(:#{name})
        
      
        

          
          
                        def #{name}
        
      
        

          
          
                          defined?(@#{name}) ? @#{name} : singleton_class.#{name}
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                    val
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          
          
                  if instance_reader
        
      
        

          
          
                    remove_possible_method :#{name}
        
      
        

          
          
                    def #{name}
        
      
        

          
          
                      defined?(@#{name}) ? @#{name} : self.class.#{name}
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                    def #{name}?
        
      
        

          
          
                      !!#{name}
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                RUBY
        
      
        

          
          
          
        
      
        

          
          
                attr_writer name if instance_writer
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          1
          
            def singleton_class?
        
      
        

          
          
              !name || '' == name
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'active_support/core_ext/object/blank'
        
      
        

          1
          
          require 'active_support/core_ext/array/extract_options'
        
      
        

          1
          
          require 'active_support/core_ext/kernel/singleton_class'
        
      
        

          1
          
          require 'active_support/core_ext/module/remove_method'
        
      
        

          
          
          
        
      
        

          1
          
          class Class
        
      
        

          1
          
            def superclass_delegating_accessor(name, options = {})
        
      
        

          
          
              # Create private _name and _name= methods that can still be used if the public
        
      
        

          
          
              # methods are overridden. This allows
        
      
        

          
          
              _superclass_delegating_accessor("_#{name}")
        
      
        

          
          
          
        
      
        

          
          
              # Generate the public methods name, name=, and name?
        
      
        

          
          
              # These methods dispatch to the private _name, and _name= methods, making them
        
      
        

          
          
              # overridable
        
      
        

          
          
              singleton_class.send(:define_method, name) { send("_#{name}") }
        
      
        

          
          
              singleton_class.send(:define_method, "#{name}?") { !!send("_#{name}") }
        
      
        

          
          
              singleton_class.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }
        
      
        

          
          
          
        
      
        

          
          
              # If an instance_reader is needed, generate methods for name and name= on the
        
      
        

          
          
              # class itself, so instances will be able to see them
        
      
        

          
          
              define_method(name) { send("_#{name}") } if options[:instance_reader] != false
        
      
        

          
          
              define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
          private
        
      
        

          
          
          
        
      
        

          
          
            # Take the object being set and store it in a method. This gives us automatic
        
      
        

          
          
            # inheritance behavior, without having to store the object in an instance
        
      
        

          
          
            # variable and look up the superclass chain manually.
        
      
        

          1
          
            def _stash_object_in_method(object, method, instance_reader = true)
        
      
        

          
          
              singleton_class.remove_possible_method(method)
        
      
        

          
          
              singleton_class.send(:define_method, method) { object }
        
      
        

          
          
              remove_possible_method(method)
        
      
        

          
          
              define_method(method) { object } if instance_reader
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def _superclass_delegating_accessor(name, options = {})
        
      
        

          
          
              singleton_class.send(:define_method, "#{name}=") do |value|
        
      
        

          
          
                _stash_object_in_method(value, name, options[:instance_reader] != false)
        
      
        

          
          
              end
        
      
        

          
          
              send("#{name}=", nil)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'active_support/core_ext/object/duplicable'
        
      
        

          1
          
          require 'active_support/core_ext/array/extract_options'
        
      
        

          1
          
          require 'active_support/deprecation'
        
      
        

          
          
          
        
      
        

          
          
          # Retained for backward compatibility.  Methods are now included in Class.
        
      
        

          1
          
          module ClassInheritableAttributes # :nodoc:
        
      
        

          1
          
            DEPRECATION_WARNING_MESSAGE = "class_inheritable_attribute is deprecated, please use class_attribute method instead. Notice their behavior are slightly different, so refer to class_attribute documentation first"
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          # It is recommended to use <tt>class_attribute</tt> over methods defined in this file. Please
        
      
        

          
          
          # refer to documentation for <tt>class_attribute</tt> for more information. Officially it is not
        
      
        

          
          
          # deprecated but <tt>class_attribute</tt> is faster.
        
      
        

          
          
          #
        
      
        

          
          
          # Allows attributes to be shared within an inheritance hierarchy. Each descendant gets a copy of
        
      
        

          
          
          # their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
        
      
        

          
          
          # to, for example, an array without those additions being shared with either their parent, siblings, or
        
      
        

          
          
          # children. This is unlike the regular class-level attributes that are shared across the entire hierarchy.
        
      
        

          
          
          #
        
      
        

          
          
          # The copies of inheritable parent attributes are added to subclasses when they are created, via the
        
      
        

          
          
          # +inherited+ hook.
        
      
        

          
          
          #
        
      
        

          
          
          #  class Person
        
      
        

          
          
          #    class_inheritable_accessor :hair_colors
        
      
        

          
          
          #  end
        
      
        

          
          
          #
        
      
        

          
          
          #  Person.hair_colors = [:brown, :black, :blonde, :red]
        
      
        

          
          
          #  Person.hair_colors     # => [:brown, :black, :blonde, :red]
        
      
        

          
          
          #  Person.new.hair_colors # => [:brown, :black, :blonde, :red]
        
      
        

          
          
          #
        
      
        

          
          
          # To opt out of the instance writer method, pass :instance_writer => false.
        
      
        

          
          
          # To opt out of the instance reader method, pass :instance_reader => false.
        
      
        

          
          
          #
        
      
        

          
          
          #   class Person
        
      
        

          
          
          #     class_inheritable_accessor :hair_colors :instance_writer => false, :instance_reader => false
        
      
        

          
          
          #   end
        
      
        

          
          
          #
        
      
        

          
          
          #   Person.new.hair_colors = [:brown]  # => NoMethodError
        
      
        

          
          
          #   Person.new.hair_colors             # => NoMethodError
        
      
        

          1
          
          class Class # :nodoc:
        
      
        

          1
          
            def class_inheritable_reader(*syms)
        
      
        

          
          
              ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
        
      
        

          
          
              options = syms.extract_options!
        
      
        

          
          
              syms.each do |sym|
        
      
        

          
          
                next if sym.is_a?(Hash)
        
      
        

          
          
                class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        
      
        

          
          
                  def self.#{sym}                                # def self.after_add
        
      
        

          
          
                    read_inheritable_attribute(:#{sym})          #   read_inheritable_attribute(:after_add)
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                                                                 #
        
      
        

          
          
                  #{"                                            #
        
      
        

          
          
                  def #{sym}                                     # def after_add
        
      
        

          
          
                    self.class.#{sym}                            #   self.class.after_add
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                  " unless options[:instance_reader] == false }  # # the reader above is generated unless options[:instance_reader] == false
        
      
        

          
          
                EOS
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def class_inheritable_writer(*syms)
        
      
        

          
          
              ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
        
      
        

          
          
              options = syms.extract_options!
        
      
        

          
          
              syms.each do |sym|
        
      
        

          
          
                class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        
      
        

          
          
                  def self.#{sym}=(obj)                          # def self.color=(obj)
        
      
        

          
          
                    write_inheritable_attribute(:#{sym}, obj)    #   write_inheritable_attribute(:color, obj)
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                                                                 #
        
      
        

          
          
                  #{"                                            #
        
      
        

          
          
                  def #{sym}=(obj)                               # def color=(obj)
        
      
        

          
          
                    self.class.#{sym} = obj                      #   self.class.color = obj
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                  " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
        
      
        

          
          
                EOS
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def class_inheritable_array_writer(*syms)
        
      
        

          
          
              ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
        
      
        

          
          
              options = syms.extract_options!
        
      
        

          
          
              syms.each do |sym|
        
      
        

          
          
                class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        
      
        

          
          
                  def self.#{sym}=(obj)                          # def self.levels=(obj)
        
      
        

          
          
                    write_inheritable_array(:#{sym}, obj)        #   write_inheritable_array(:levels, obj)
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                                                                 #
        
      
        

          
          
                  #{"                                            #
        
      
        

          
          
                  def #{sym}=(obj)                               # def levels=(obj)
        
      
        

          
          
                    self.class.#{sym} = obj                      #   self.class.levels = obj
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                  " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
        
      
        

          
          
                EOS
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def class_inheritable_hash_writer(*syms)
        
      
        

          
          
              ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
        
      
        

          
          
              options = syms.extract_options!
        
      
        

          
          
              syms.each do |sym|
        
      
        

          
          
                class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        
      
        

          
          
                  def self.#{sym}=(obj)                          # def self.nicknames=(obj)
        
      
        

          
          
                    write_inheritable_hash(:#{sym}, obj)         #   write_inheritable_hash(:nicknames, obj)
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                                                                 #
        
      
        

          
          
                  #{"                                            #
        
      
        

          
          
                  def #{sym}=(obj)                               # def nicknames=(obj)
        
      
        

          
          
                    self.class.#{sym} = obj                      #   self.class.nicknames = obj
        
      
        

          
          
                  end                                            # end
        
      
        

          
          
                  " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
        
      
        

          
          
                EOS
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def class_inheritable_accessor(*syms)
        
      
        

          
          
              class_inheritable_reader(*syms)
        
      
        

          
          
              class_inheritable_writer(*syms)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def class_inheritable_array(*syms)
        
      
        

          
          
              class_inheritable_reader(*syms)
        
      
        

          
          
              class_inheritable_array_writer(*syms)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def class_inheritable_hash(*syms)
        
      
        

          
          
              class_inheritable_reader(*syms)
        
      
        

          
          
              class_inheritable_hash_writer(*syms)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def inheritable_attributes
        
      
        

          140
          
              @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def write_inheritable_attribute(key, value)
        
      
        

          
          
              if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
        
      
        

          
          
                @inheritable_attributes = {}
        
      
        

          
          
              end
        
      
        

          
          
              inheritable_attributes[key] = value
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def write_inheritable_array(key, elements)
        
      
        

          
          
              write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
        
      
        

          
          
              write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def write_inheritable_hash(key, hash)
        
      
        

          
          
              write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
        
      
        

          
          
              write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def read_inheritable_attribute(key)
        
      
        

          
          
              inheritable_attributes[key]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def reset_inheritable_attributes
        
      
        

          
          
              ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
        
      
        

          
          
              @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
              # Prevent this constant from being created multiple times
        
      
        

          1
          
              EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze
        
      
        

          
          
          
        
      
        

          1
          
              def inherited_with_inheritable_attributes(child)
        
      
        

          140
          
                inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
        
      
        

          
          
          
        
      
        

          140
          
                if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
        
      
        

          140
          
                  new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
        
      
        

          
          
                else
        
      
        

          
          
                  new_inheritable_attributes = Hash[inheritable_attributes.map do |(key, value)|
        
      
        

          
          
                    [key, value.duplicable? ? value.dup : value]
        
      
        

          
          
                  end]
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          140
          
                child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              alias inherited_without_inheritable_attributes inherited
        
      
        

          1
          
              alias inherited inherited_with_inheritable_attributes
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'active_support/core_ext/module/anonymous'
        
      
        

          1
          
          require 'active_support/core_ext/module/reachable'
        
      
        

          
          
          
        
      
        

          1
          
          class Class #:nodoc:
        
      
        

          1
          
            begin
        
      
        

          1
          
              ObjectSpace.each_object(Class.new) {}
        
      
        

          
          
          
        
      
        

          1
          
              def descendants
        
      
        

          
          
                descendants = []
        
      
        

          
          
                ObjectSpace.each_object(class << self; self; end) do |k|
        
      
        

          
          
                  descendants.unshift k unless k == self
        
      
        

          
          
                end
        
      
        

          
          
                descendants
        
      
        

          
          
              end
        
      
        

          
          
            rescue StandardError # JRuby
        
      
        

          
          
              def descendants
        
      
        

          
          
                descendants = []
        
      
        

          
          
                ObjectSpace.each_object(Class) do |k|
        
      
        

          
          
                  descendants.unshift k if k < self
        
      
        

          
          
                end
        
      
        

          
          
                descendants.uniq!
        
      
        

          
          
                descendants
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns an array with the direct children of +self+.
        
      
        

          
          
            #
        
      
        

          
          
            #   Integer.subclasses # => [Bignum, Fixnum]
        
      
        

          1
          
            def subclasses
        
      
        

          
          
              subclasses, chain = [], descendants
        
      
        

          
          
              chain.each do |k|
        
      
        

          
          
                subclasses << k unless chain.any? { |c| c > k }
        
      
        

          
          
              end
        
      
        

          
          
              subclasses
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'date'
        
      
        

          1
          
          require 'active_support/duration'
        
      
        

          1
          
          require 'active_support/core_ext/object/acts_like'
        
      
        

          1
          
          require 'active_support/core_ext/date/zones'
        
      
        

          1
          
          require 'active_support/core_ext/time/zones'
        
      
        

          
          
          
        
      
        

          1
          
          class Date
        
      
        

          1
          
            DAYS_INTO_WEEK = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6 }
        
      
        

          
          
          
        
      
        

          1
          
            if RUBY_VERSION < '1.9'
        
      
        

          
          
              undef :>>
        
      
        

          
          
          
        
      
        

          
          
              # Backported from 1.9. The one in 1.8 leads to incorrect next_month and
        
      
        

          
          
              # friends for dates where the calendar reform is involved. It additionally
        
      
        

          
          
              # prevents an infinite loop fixed in r27013.
        
      
        

          
          
              def >>(n)
        
      
        

          
          
                y, m = (year * 12 + (mon - 1) + n).divmod(12)
        
      
        

          
          
                m,   = (m + 1)                    .divmod(1)
        
      
        

          
          
                d = mday
        
      
        

          
          
                until jd2 = self.class.valid_civil?(y, m, d, start)
        
      
        

          
          
                  d -= 1
        
      
        

          
          
                  raise ArgumentError, 'invalid date' unless d > 0
        
      
        

          
          
                end
        
      
        

          
          
                self + (jd2 - jd)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            class << self
        
      
        

          
          
              # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
        
      
        

          1
          
              def yesterday
        
      
        

          
          
                ::Date.current.yesterday
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
        
      
        

          1
          
              def tomorrow
        
      
        

          
          
                ::Date.current.tomorrow
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns Time.zone.today when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns Date.today.
        
      
        

          1
          
              def current
        
      
        

          
          
                ::Time.zone ? ::Time.zone.today : ::Date.today
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns true if the Date object's date lies in the past. Otherwise returns false.
        
      
        

          1
          
            def past?
        
      
        

          
          
              self < ::Date.current
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns true if the Date object's date is today.
        
      
        

          1
          
            def today?
        
      
        

          
          
              self.to_date == ::Date.current # we need the to_date because of DateTime
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns true if the Date object's date lies in the future.
        
      
        

          1
          
            def future?
        
      
        

          
          
              self > ::Date.current
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
        
      
        

          
          
            # and then subtracts the specified number of seconds.
        
      
        

          1
          
            def ago(seconds)
        
      
        

          
          
              to_time_in_current_zone.since(-seconds)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
        
      
        

          
          
            # and then adds the specified number of seconds
        
      
        

          1
          
            def since(seconds)
        
      
        

          
          
              to_time_in_current_zone.since(seconds)
        
      
        

          
          
            end
        
      
        

          1
          
            alias :in :since
        
      
        

          
          
          
        
      
        

          
          
            # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
        
      
        

          1
          
            def beginning_of_day
        
      
        

          
          
              to_time_in_current_zone
        
      
        

          
          
            end
        
      
        

          1
          
            alias :midnight :beginning_of_day
        
      
        

          1
          
            alias :at_midnight :beginning_of_day
        
      
        

          1
          
            alias :at_beginning_of_day :beginning_of_day
        
      
        

          
          
          
        
      
        

          
          
            # Converts Date to a Time (or DateTime if necessary) with the time portion set to the end of the day (23:59:59)
        
      
        

          1
          
            def end_of_day
        
      
        

          
          
              to_time_in_current_zone.end_of_day
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def plus_with_duration(other) #:nodoc:
        
      
        

          
          
              if ActiveSupport::Duration === other
        
      
        

          
          
                other.since(self)
        
      
        

          
          
              else
        
      
        

          
          
                plus_without_duration(other)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          1
          
            alias_method :plus_without_duration, :+
        
      
        

          1
          
            alias_method :+, :plus_with_duration
        
      
        

          
          
          
        
      
        

          1
          
            def minus_with_duration(other) #:nodoc:
        
      
        

          
          
              if ActiveSupport::Duration === other
        
      
        

          
          
                plus_with_duration(-other)
        
      
        

          
          
              else
        
      
        

          
          
                minus_without_duration(other)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          1
          
            alias_method :minus_without_duration, :-
        
      
        

          1
          
            alias_method :-, :minus_with_duration
        
      
        

          
          
          
        
      
        

          
          
            # Provides precise Date calculations for years, months, and days.  The +options+ parameter takes a hash with
        
      
        

          
          
            # any of these keys: <tt>:years</tt>, <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>.
        
      
        

          1
          
            def advance(options)
        
      
        

          
          
              options = options.dup
        
      
        

          
          
              d = self
        
      
        

          
          
              d = d >> options.delete(:years) * 12 if options[:years]
        
      
        

          
          
              d = d >> options.delete(:months)     if options[:months]
        
      
        

          
          
              d = d +  options.delete(:weeks) * 7  if options[:weeks]
        
      
        

          
          
              d = d +  options.delete(:days)       if options[:days]
        
      
        

          
          
              d
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
        
      
        

          
          
            #
        
      
        

          
          
            # Examples:
        
      
        

          
          
            #
        
      
        

          
          
            #   Date.new(2007, 5, 12).change(:day => 1)                  # => Date.new(2007, 5, 1)
        
      
        

          
          
            #   Date.new(2007, 5, 12).change(:year => 2005, :month => 1) # => Date.new(2005, 1, 12)
        
      
        

          1
          
            def change(options)
        
      
        

          
          
              ::Date.new(
        
      
        

          
          
                options[:year]  || self.year,
        
      
        

          
          
                options[:month] || self.month,
        
      
        

          
          
                options[:day]   || self.day
        
      
        

          
          
              )
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the time a number of specified weeks ago.
        
      
        

          1
          
            def weeks_ago(weeks)
        
      
        

          
          
              advance(:weeks => -weeks)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the time a number of specified months ago.
        
      
        

          1
          
            def months_ago(months)
        
      
        

          
          
              advance(:months => -months)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the time a number of specified months in the future.
        
      
        

          1
          
            def months_since(months)
        
      
        

          
          
              advance(:months => months)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the time a number of specified years ago.
        
      
        

          1
          
            def years_ago(years)
        
      
        

          
          
              advance(:years => -years)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the time a number of specified years in the future.
        
      
        

          1
          
            def years_since(years)
        
      
        

          
          
              advance(:years => years)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Shorthand for years_ago(1)
        
      
        

          
          
            def prev_year
        
      
        

          
          
              years_ago(1)
        
      
        

          1
          
            end unless method_defined?(:prev_year)
        
      
        

          
          
          
        
      
        

          
          
            # Shorthand for years_since(1)
        
      
        

          
          
            def next_year
        
      
        

          
          
              years_since(1)
        
      
        

          1
          
            end unless method_defined?(:next_year)
        
      
        

          
          
          
        
      
        

          
          
            # Shorthand for months_ago(1)
        
      
        

          
          
            def prev_month
        
      
        

          
          
              months_ago(1)
        
      
        

          1
          
            end unless method_defined?(:prev_month)
        
      
        

          
          
          
        
      
        

          
          
            # Shorthand for months_since(1)
        
      
        

          
          
            def next_month
        
      
        

          
          
              months_since(1)
        
      
        

          1
          
            end unless method_defined?(:next_month)
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the "start" of this week (i.e, Monday; DateTime objects will have time set to 0:00).
        
      
        

          1
          
            def beginning_of_week
        
      
        

          
          
              days_to_monday = self.wday!=0 ? self.wday-1 : 6
        
      
        

          
          
              result = self - days_to_monday
        
      
        

          
          
              self.acts_like?(:time) ? result.midnight : result
        
      
        

          
          
            end
        
      
        

          1
          
            alias :monday :beginning_of_week
        
      
        

          1
          
            alias :at_beginning_of_week :beginning_of_week
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the end of this week (Sunday, DateTime objects will have time set to 23:59:59).
        
      
        

          1
          
            def end_of_week
        
      
        

          
          
              days_to_sunday = self.wday!=0 ? 7-self.wday : 0
        
      
        

          
          
              result = self + days_to_sunday.days
        
      
        

          
          
              self.acts_like?(:time) ? result.end_of_day : result
        
      
        

          
          
            end
        
      
        

          1
          
            alias :sunday :end_of_week
        
      
        

          1
          
            alias :at_end_of_week :end_of_week
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the start of the given day in the previous week (default is Monday).
        
      
        

          1
          
            def prev_week(day = :monday)
        
      
        

          
          
              result = (self - 7).beginning_of_week + DAYS_INTO_WEEK[day]
        
      
        

          
          
              self.acts_like?(:time) ? result.change(:hour => 0) : result
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the start of the given day in next week (default is Monday).
        
      
        

          1
          
            def next_week(day = :monday)
        
      
        

          
          
              result = (self + 7).beginning_of_week + DAYS_INTO_WEEK[day]
        
      
        

          
          
              self.acts_like?(:time) ? result.change(:hour => 0) : result
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new ; DateTime objects will have time set to 0:00DateTime representing the start of the month (1st of the month; DateTime objects will have time set to 0:00)
        
      
        

          1
          
            def beginning_of_month
        
      
        

          
          
              self.acts_like?(:time) ? change(:day => 1, :hour => 0) : change(:day => 1)
        
      
        

          
          
            end
        
      
        

          1
          
            alias :at_beginning_of_month :beginning_of_month
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the end of the month (last day of the month; DateTime objects will have time set to 0:00)
        
      
        

          1
          
            def end_of_month
        
      
        

          
          
              last_day = ::Time.days_in_month( self.month, self.year )
        
      
        

          
          
              self.acts_like?(:time) ? change(:day => last_day, :hour => 23, :min => 59, :sec => 59) : change(:day => last_day)
        
      
        

          
          
            end
        
      
        

          1
          
            alias :at_end_of_month :end_of_month
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the start of the quarter (1st of january, april, july, october; DateTime objects will have time set to 0:00)
        
      
        

          1
          
            def beginning_of_quarter
        
      
        

          
          
              beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= self.month })
        
      
        

          
          
            end
        
      
        

          1
          
            alias :at_beginning_of_quarter :beginning_of_quarter
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the end of the quarter (last day of march, june, september, december; DateTime objects will have time set to 23:59:59)
        
      
        

          1
          
            def end_of_quarter
        
      
        

          
          
              beginning_of_month.change(:month => [3, 6, 9, 12].detect { |m| m >= self.month }).end_of_month
        
      
        

          
          
            end
        
      
        

          1
          
            alias :at_end_of_quarter :end_of_quarter
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Date/DateTime representing the start of the year (1st of january; DateTime objects will have time set to 0:00)
        
      
        

          1
          
            def beginning_of_year
        
      
        

          
          
              self.acts_like?(:time) ? change(:month => 1, :day => 1, :hour => 0) : change(:month => 1, :day => 1)
        
      
        

          
          
            end
        
      
        

          1
          
            alias :at_beginning_of_year :beginning_of_year
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new Time representing the end of the year (31st of december; DateTime objects will have time set to 23:59:59)
        
      
        

          1
          
            def end_of_year
        
      
        

          
          
              self.acts_like?(:time) ? change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59) : change(:month => 12, :day => 31)
        
      
        

          
          
            end
        
      
        

          1
          
            alias :at_end_of_year :end_of_year
        
      
        

          
          
          
        
      
        

          
          
            # Convenience method which returns a new Date/DateTime representing the time 1 day ago
        
      
        

          1
          
            def yesterday
        
      
        

          
          
              self - 1
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Convenience method which returns a new Date/DateTime representing the time 1 day since the instance time
        
      
        

          1
          
            def tomorrow
        
      
        

          
          
              self + 1
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'date'
        
      
        

          1
          
          require 'active_support/core_ext/time/zones'
        
      
        

          
          
          
        
      
        

          1
          
          class Date
        
      
        

          
          
            # Converts Date to a TimeWithZone in the current zone if Time.zone or Time.zone_default
        
      
        

          
          
            # is set, otherwise converts Date to a Time via Date#to_time
        
      
        

          1
          
            def to_time_in_current_zone
        
      
        

          
          
              if ::Time.zone
        
      
        

          
          
                ::Time.zone.local(year, month, day)
        
      
        

          
          
              else
        
      
        

          
          
                to_time
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'rational' unless RUBY_VERSION >= '1.9.2'
        
      
        

          
          
          
        
      
        

          1
          
          class DateTime
        
      
        

          1
          
            class << self
        
      
        

          
          
              # DateTimes aren't aware of DST rules, so use a consistent non-DST offset when creating a DateTime with an offset in the local zone
        
      
        

          1
          
              def local_offset
        
      
        

          
          
                ::Time.local(2007).utc_offset.to_r / 86400
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns <tt>Time.zone.now.to_datetime</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise returns <tt>Time.now.to_datetime</tt>.
        
      
        

          1
          
              def current
        
      
        

          
          
                ::Time.zone ? ::Time.zone.now.to_datetime : ::Time.now.to_datetime
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Tells whether the DateTime object's datetime lies in the past
        
      
        

          1
          
            def past?
        
      
        

          
          
              self < ::DateTime.current
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Tells whether the DateTime object's datetime lies in the future
        
      
        

          1
          
            def future?
        
      
        

          
          
              self > ::DateTime.current
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Seconds since midnight: DateTime.now.seconds_since_midnight
        
      
        

          1
          
            def seconds_since_midnight
        
      
        

          
          
              sec + (min * 60) + (hour * 3600)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new DateTime where one or more of the elements have been changed according to the +options+ parameter. The time options
        
      
        

          
          
            # (hour, minute, sec) reset cascadingly, so if only the hour is passed, then minute and sec is set to 0. If the hour and
        
      
        

          
          
            # minute is passed, then sec is set to 0.
        
      
        

          1
          
            def change(options)
        
      
        

          
          
              ::DateTime.civil(
        
      
        

          
          
                options[:year]  || year,
        
      
        

          
          
                options[:month] || month,
        
      
        

          
          
                options[:day]   || day,
        
      
        

          
          
                options[:hour]  || hour,
        
      
        

          
          
                options[:min]   || (options[:hour] ? 0 : min),
        
      
        

          
          
                options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec),
        
      
        

          
          
                options[:offset]  || offset,
        
      
        

          
          
                options[:start]  || start
        
      
        

          
          
              )
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Uses Date to provide precise Time calculations for years, months, and days.
        
      
        

          
          
            # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
        
      
        

          
          
            # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
        
      
        

          
          
            # <tt>:minutes</tt>, <tt>:seconds</tt>.
        
      
        

          1
          
            def advance(options)
        
      
        

          
          
              d = to_date.advance(options)
        
      
        

          
          
              datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
        
      
        

          
          
              seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
        
      
        

          
          
              seconds_to_advance == 0 ? datetime_advanced_by_date : datetime_advanced_by_date.since(seconds_to_advance)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new DateTime representing the time a number of seconds ago
        
      
        

          
          
            # Do not use this method in combination with x.months, use months_ago instead!
        
      
        

          1
          
            def ago(seconds)
        
      
        

          
          
              since(-seconds)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new DateTime representing the time a number of seconds since the instance time
        
      
        

          
          
            # Do not use this method in combination with x.months, use months_since instead!
        
      
        

          1
          
            def since(seconds)
        
      
        

          
          
              self + Rational(seconds.round, 86400)
        
      
        

          
          
            end
        
      
        

          1
          
            alias :in :since
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new DateTime representing the start of the day (0:00)
        
      
        

          1
          
            def beginning_of_day
        
      
        

          
          
              change(:hour => 0)
        
      
        

          
          
            end
        
      
        

          1
          
            alias :midnight :beginning_of_day
        
      
        

          1
          
            alias :at_midnight :beginning_of_day
        
      
        

          1
          
            alias :at_beginning_of_day :beginning_of_day
        
      
        

          
          
          
        
      
        

          
          
            # Returns a new DateTime representing the end of the day (23:59:59)
        
      
        

          1
          
            def end_of_day
        
      
        

          
          
              change(:hour => 23, :min => 59, :sec => 59)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # 1.9.3 defines + and - on DateTime, < 1.9.3 do not.
        
      
        

          1
          
            if DateTime.public_instance_methods(false).include?(:+)
        
      
        

          
          
              def plus_with_duration(other) #:nodoc:
        
      
        

          
          
                if ActiveSupport::Duration === other
        
      
        

          
          
                  other.since(self)
        
      
        

          
          
                else
        
      
        

          
          
                  plus_without_duration(other)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              alias_method :plus_without_duration, :+
        
      
        

          
          
              alias_method :+, :plus_with_duration
        
      
        

          
          
          
        
      
        

          
          
              def minus_with_duration(other) #:nodoc:
        
      
        

          
          
                if ActiveSupport::Duration === other
        
      
        

          
          
                  plus_with_duration(-other)
        
      
        

          
          
                else
        
      
        

          
          
                  minus_without_duration(other)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              alias_method :minus_without_duration, :-
        
      
        

          
          
              alias_method :-, :minus_with_duration
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Adjusts DateTime to UTC by adding its offset value; offset is set to 0
        
      
        

          
          
            #
        
      
        

          
          
            # Example:
        
      
        

          
          
            #
        
      
        

          
          
            #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))       # => Mon, 21 Feb 2005 10:11:12 -0600
        
      
        

          
          
            #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc   # => Mon, 21 Feb 2005 16:11:12 +0000
        
      
        

          1
          
            def utc
        
      
        

          
          
              new_offset(0)
        
      
        

          
          
            end
        
      
        

          1
          
            alias_method :getutc, :utc
        
      
        

          
          
          
        
      
        

          
          
            # Returns true if offset == 0
        
      
        

          1
          
            def utc?
        
      
        

          
          
              offset == 0
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Returns the offset value in seconds
        
      
        

          1
          
            def utc_offset
        
      
        

          
          
              (offset * 86400).to_i
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Layers additional behavior on DateTime#<=> so that Time and ActiveSupport::TimeWithZone instances can be compared with a DateTime
        
      
        

          1
          
            def <=>(other)
        
      
        

          
          
              super other.to_datetime
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'active_support/inflector/methods'
        
      
        

          1
          
          require 'active_support/core_ext/time/conversions'
        
      
        

          1
          
          require 'active_support/core_ext/date_time/calculations'
        
      
        

          1
          
          require 'active_support/values/time_zone'
        
      
        

          
          
          
        
      
        

          1
          
          class DateTime
        
      
        

          
          
            # Ruby 1.9 has DateTime#to_time which internally relies on Time. We define our own #to_time which allows
        
      
        

          
          
            # DateTimes outside the range of what can be created with Time.
        
      
        

          1
          
            remove_method :to_time if instance_methods.include?(:to_time)
        
      
        

          
          
          
        
      
        

          
          
            # Convert to a formatted string. See Time::DATE_FORMATS for predefined formats.
        
      
        

          
          
            #
        
      
        

          
          
            # This method is aliased to <tt>to_s</tt>.
        
      
        

          
          
            #
        
      
        

          
          
            # === Examples
        
      
        

          
          
            #   datetime = DateTime.civil(2007, 12, 4, 0, 0, 0, 0)   # => Tue, 04 Dec 2007 00:00:00 +0000
        
      
        

          
          
            #
        
      
        

          
          
            #   datetime.to_formatted_s(:db)            # => "2007-12-04 00:00:00"
        
      
        

          
          
            #   datetime.to_s(:db)                      # => "2007-12-04 00:00:00"
        
      
        

          
          
            #   datetime.to_s(:number)                  # => "20071204000000"
        
      
        

          
          
            #   datetime.to_formatted_s(:short)         # => "04 Dec 00:00"
        
      
        

          
          
            #   datetime.to_formatted_s(:long)          # => "December 04, 2007 00:00"
        
      
        

          
          
            #   datetime.to_formatted_s(:long_ordinal)  # => "December 4th, 2007 00:00"
        
      
        

          
          
            #   datetime.to_formatted_s(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
        
      
        

          
          
            #
        
      
        

          
          
            # == Adding your own datetime formats to to_formatted_s
        
      
        

          
          
            # DateTime formats are shared with Time. You can add your own to the
        
      
        

          
          
            # Time::DATE_FORMATS hash. Use the format name as the hash key and
        
      
        

          
          
            # either a strftime string or Proc instance that takes a time or
        
      
        

          
          
            # datetime argument as the value.
        
      
        

          
          
            #
        
      
        

          
          
            #   # config/initializers/time_formats.rb
        
      
        

          
          
            #   Time::DATE_FORMATS[:month_and_year] = "%B %Y"
        
      
        

          
          
            #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
        
      
        

          1
          
            def to_formatted_s(format = :default)
        
      
        

          
          
              if formatter = ::Time::DATE_FORMATS[format]
        
      
        

          
          
                formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
        
      
        

          
          
              else
        
      
        

          
          
                to_default_s
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          1
          
            alias_method :to_default_s, :to_s unless (instance_methods(false) & [:to_s, 'to_s']).empty?
        
      
        

          1
          
            alias_method :to_s, :to_formatted_s
        
      
        

          
          
          
        
      
        

          
          
            # Returns the +utc_offset+ as an +HH:MM formatted string. Examples:
        
      
        

          
          
            #
        
      
        

          
          
            #   datetime = DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-6, 24))
        
      
        

          
          
            #   datetime.formatted_offset         # => "-06:00"
        
      
        

          
          
            #   datetime.formatted_offset(false)  # => "-0600"
        
      
        

          1
          
            def formatted_offset(colon = true, alternate_utc_string = nil)
        
      
        

          
          
              utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005 14:30:00 +0000".
        
      
        

          1
          
            def readable_inspect
        
      
        

          
          
              to_s(:rfc822)
        
      
        

          
          
            end
        
      
        

          1
          
            alias_method :default_inspect, :inspect
        
      
        

          1
          
            alias_method :inspect, :readable_inspect
        
      
        

          
          
          
        
      
        

          
          
            # Converts self to a Ruby Date object; time portion is discarded.
        
      
        

          
          
            def to_date
        
      
        

          
          
              ::Date.new(year, month, day)
        
      
        

          1
          
            end unless instance_methods(false).include?(:to_date)
        
      
        

          
          
          
        
      
        

          
          
            # Attempts to convert self to a Ruby Time object; returns self if out of range of Ruby Time class.
        
      
        

          
          
            # If self has an offset other than 0, self will just be returned unaltered, since there's no clean way to map it to a Time.
        
      
        

          1
          
            def to_time
        
      
        

          
          
              self.offset == 0 ? ::Time.utc_time(year, month, day, hour, min, sec, sec_fraction * (RUBY_VERSION < '1.9' ? 86400000000 : 1000000)) : self
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # To be able to keep Times, Dates and DateTimes interchangeable on conversions.
        
      
        

          
          
            def to_datetime
        
      
        

          
          
              self
        
      
        

          1
          
            end unless instance_methods(false).include?(:to_datetime)
        
      
        

          
          
          
        
      
        

          1
          
            def self.civil_from_format(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0)
        
      
        

          
          
              offset = utc_or_local.to_sym == :local ? local_offset : 0
        
      
        

          
          
              civil(year, month, day, hour, min, sec, offset)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Converts datetime to an appropriate format for use in XML.
        
      
        

          
          
            def xmlschema
        
      
        

          
          
              strftime("%Y-%m-%dT%H:%M:%S%Z")
        
      
        

          1
          
            end unless instance_methods(false).include?(:xmlschema)
        
      
        

          
          
          
        
      
        

          
          
            # Converts self to a floating-point number of seconds since the Unix epoch.
        
      
        

          1
          
            def to_f
        
      
        

          
          
              seconds_since_unix_epoch.to_f
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Converts self to an integer number of seconds since the Unix epoch.
        
      
        

          1
          
            def to_i
        
      
        

          
          
              seconds_since_unix_epoch.to_i
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def seconds_since_unix_epoch
        
      
        

          
          
              seconds_per_day = 86_400
        
      
        

          
          
              (self - ::DateTime.civil(1970)) * seconds_per_day
        
      
        

          
          
            end
        
      
        

          
          
          end